The-Homebrew-Cloud
/
libgui
mirror of https://github.com/wiiu-env/libgui.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Formatting

This commit is contained in:
Maschell 2020-08-13 12:38:07 +02:00
parent 61917ce2a4
commit 2b42bbd60f
81 changed files with 4978 additions and 4570 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -6,3 +6,5 @@ lib/
libgui.layout
obj/
CMakeLists.txt
cmake-build-debug/
.idea/

54
include/gui/FreeTypeGX.h
View File

@ -57,7 +57,7 @@ typedef struct ftgxCharData_ {
int16_t renderOffsetMax; /**< Texture Y axis bearing maximum value. */
int16_t renderOffsetMin; /**< Texture Y axis bearing minimum value. */
GX2Texture * texture;
GX2Texture *texture;
} ftgxCharData;
/*! \struct ftgxDataOffset_
@ -75,28 +75,28 @@ typedef struct ftgxCharData_ ftgxCharData;
typedef struct ftgxDataOffset_ ftgxDataOffset;
#define _TEXT(t) L ## t /**< Unicode helper macro. */
#define FTGX_NULL 0x0000
#define FTGX_JUSTIFY_LEFT 0x0001
#define FTGX_JUSTIFY_CENTER 0x0002
#define FTGX_JUSTIFY_RIGHT 0x0004
#define FTGX_JUSTIFY_MASK 0x000f
#define FTGX_NULL 0x0000
#define FTGX_JUSTIFY_LEFT 0x0001
#define FTGX_JUSTIFY_CENTER 0x0002
#define FTGX_JUSTIFY_RIGHT 0x0004
#define FTGX_JUSTIFY_MASK 0x000f
#define FTGX_ALIGN_TOP 0x0010
#define FTGX_ALIGN_MIDDLE 0x0020
#define FTGX_ALIGN_BOTTOM 0x0040
#define FTGX_ALIGN_BASELINE 0x0080
#define FTGX_ALIGN_GLYPH_TOP 0x0100
#define FTGX_ALIGN_TOP 0x0010
#define FTGX_ALIGN_MIDDLE 0x0020
#define FTGX_ALIGN_BOTTOM 0x0040
#define FTGX_ALIGN_BASELINE 0x0080
#define FTGX_ALIGN_GLYPH_TOP 0x0100
#define FTGX_ALIGN_GLYPH_MIDDLE 0x0200
#define FTGX_ALIGN_GLYPH_BOTTOM 0x0400
#define FTGX_ALIGN_MASK 0x0ff0
#define FTGX_ALIGN_MASK 0x0ff0
#define FTGX_STYLE_UNDERLINE 0x1000
#define FTGX_STYLE_STRIKE 0x2000
#define FTGX_STYLE_MASK 0xf000
#define FTGX_STYLE_UNDERLINE 0x1000
#define FTGX_STYLE_STRIKE 0x2000
#define FTGX_STYLE_MASK 0xf000
/**< Constant color value used only to sanitize Doxygen documentation. */
static const GX2ColorF32 ftgxWhite = (GX2ColorF32) {
1.0f, 1.0f, 1.0f, 1.0f
1.0f, 1.0f, 1.0f, 1.0f
};
@ -129,29 +129,39 @@ private:
std::map<int16_t, ftGX2Data> fontData; /**< Map which holds the glyph data structures for the corresponding characters in one size. */
int16_t getStyleOffsetWidth(uint16_t width, uint16_t format);
int16_t getStyleOffsetHeight(int16_t format, uint16_t pixelSize);
void unloadFont();
ftgxCharData *cacheGlyphData(wchar_t charCode, int16_t pixelSize);
uint16_t cacheGlyphDataComplete(int16_t pixelSize);
void loadGlyphData(FT_Bitmap *bmp, ftgxCharData *charData);
void copyTextureToFramebuffer(CVideo * pVideo, GX2Texture *tex, int16_t screenX, int16_t screenY, int16_t screenZ, const glm::vec4 & color, const float &textBlur, const float &colorBlurIntensity, const glm::vec4 & blurColor, const float & internalRenderingScale);
void copyTextureToFramebuffer(CVideo *pVideo, GX2Texture *tex, int16_t screenX, int16_t screenY, int16_t screenZ, const glm::vec4 &color, const float &textBlur, const float &colorBlurIntensity, const glm::vec4 &blurColor,
const float &internalRenderingScale);
public:
FreeTypeGX(const uint8_t* fontBuffer, FT_Long bufferSize, bool lastFace = false);
FreeTypeGX(const uint8_t *fontBuffer, FT_Long bufferSize, bool lastFace = false);
~FreeTypeGX();
uint16_t drawText(CVideo * pVideo, int16_t x, int16_t y, int16_t z, const wchar_t *text, int16_t pixelSize, const glm::vec4 & color,
uint16_t textStyling, uint16_t textWidth, const float &textBlur, const float &colorBlurIntensity, const glm::vec4 & blurColor, const float & internalRenderingScale);
uint16_t drawText(CVideo *pVideo, int16_t x, int16_t y, int16_t z, const wchar_t *text, int16_t pixelSize, const glm::vec4 &color,
uint16_t textStyling, uint16_t textWidth, const float &textBlur, const float &colorBlurIntensity, const glm::vec4 &blurColor, const float &internalRenderingScale);
uint16_t getWidth(const wchar_t *text, int16_t pixelSize);
uint16_t getCharWidth(const wchar_t wChar, int16_t pixelSize, const wchar_t prevChar = 0x0000);
uint16_t getHeight(const wchar_t *text, int16_t pixelSize);
void getOffset(const wchar_t *text, int16_t pixelSize, uint16_t widthLimit = 0);
static wchar_t* charToWideChar(const char* p);
static char* wideCharToUTF8(const wchar_t* strChar);
static wchar_t *charToWideChar(const char *p);
static char *wideCharToUTF8(const wchar_t *strChar);
};
#endif /* FREETYPEGX_H_ */

6
include/gui/GameBgImage.h
View File

@ -6,14 +6,16 @@
class GameBgImage : public GuiImageAsync {
public:
GameBgImage(const std::string & filename, GuiImageData *preloadImage);
GameBgImage(const std::string &filename, GuiImageData *preloadImage);
virtual ~GameBgImage();
void setAlphaFadeOut(const glm::vec4 & a) {
void setAlphaFadeOut(const glm::vec4 &a) {
alphaFadeOut = a;
}
void draw(CVideo *pVideo);
private:
glm::mat4 identity;
glm::vec4 alphaFadeOut;

13
include/gui/GridBackground.h
View File

@ -6,18 +6,23 @@
class GridBackground : public GuiImage {
public:
GridBackground(GuiImageData *imgData);
virtual ~GridBackground();
void setColorIntensity(const glm::vec4 & color) {
void setColorIntensity(const glm::vec4 &color) {
colorIntensity = color;
}
const glm::vec4 & getColorIntensity() const {
const glm::vec4 &getColorIntensity() const {
return colorIntensity;
}
void setDistanceFadeOut(const float & a) {
void setDistanceFadeOut(const float &a) {
distanceFadeOut = a;
}
void draw(CVideo *pVideo, const glm::mat4 & modelView);
void draw(CVideo *pVideo, const glm::mat4 &modelView);
private:
glm::mat4 m_modelView;
glm::vec4 colorIntensity;

79
include/gui/GuiButton.h
View File

@ -32,59 +32,76 @@ public:
//!\param w Width
//!\param h Height
GuiButton(float w, float h);
//!Destructor
virtual ~GuiButton();
//!Sets the button's image
//!\param i Pointer to GuiImage object
void setImage(GuiImage* i);
void setImage(GuiImage *i);
//!Sets the button's image on over
//!\param i Pointer to GuiImage object
void setImageOver(GuiImage* i);
void setImageOver(GuiImage *i);
void setIcon(GuiImage *i);
void setIconOver(GuiImage *i);
void setIcon(GuiImage* i);
void setIconOver(GuiImage* i);
//!Sets the button's image on hold
//!\param i Pointer to GuiImage object
void setImageHold(GuiImage* i);
void setImageHold(GuiImage *i);
//!Sets the button's image on click
//!\param i Pointer to GuiImage object
void setImageClick(GuiImage* i);
void setImageClick(GuiImage *i);
//!Sets the button's label
//!\param t Pointer to GuiText object
//!\param n Index of label to set (optional, default is 0)
void setLabel(GuiText* t, int32_t n = 0);
void setLabel(GuiText *t, int32_t n = 0);
//!Sets the button's label on over (eg: different colored text)
//!\param t Pointer to GuiText object
//!\param n Index of label to set (optional, default is 0)
void setLabelOver(GuiText* t, int32_t n = 0);
void setLabelOver(GuiText *t, int32_t n = 0);
//!Sets the button's label on hold
//!\param t Pointer to GuiText object
//!\param n Index of label to set (optional, default is 0)
void setLabelHold(GuiText* t, int32_t n = 0);
void setLabelHold(GuiText *t, int32_t n = 0);
//!Sets the button's label on click
//!\param t Pointer to GuiText object
//!\param n Index of label to set (optional, default is 0)
void setLabelClick(GuiText* t, int32_t n = 0);
void setLabelClick(GuiText *t, int32_t n = 0);
//!Sets the sound to play on over
//!\param s Pointer to GuiSound object
void setSoundOver(GuiSound * s);
void setSoundOver(GuiSound *s);
//!Sets the sound to play on hold
//!\param s Pointer to GuiSound object
void setSoundHold(GuiSound * s);
void setSoundHold(GuiSound *s);
//!Sets the sound to play on click
//!\param s Pointer to GuiSound object
void setSoundClick(GuiSound * s);
void setSoundClick(GuiSound *s);
//!Set a new GuiTrigger for the element
//!\param i Index of trigger array to set
//!\param t Pointer to GuiTrigger
void setTrigger(GuiTrigger * t, int32_t idx = -1);
void setTrigger(GuiTrigger *t, int32_t idx = -1);
//!
void resetState(void);
//!Constantly called to draw the GuiButton
void draw(CVideo *video);
//!Constantly called to allow the GuiButton to respond to updated input data
//!\param t Pointer to a GuiTrigger, containing the current input data from PAD/WPAD
void update(GuiController * c);
void update(GuiController *c);
sigslot::signal2<GuiButton *, const GuiController *> selected;
sigslot::signal2<GuiButton *, const GuiController *> deSelected;
@ -96,22 +113,22 @@ public:
protected:
static const int32_t iMaxGuiTriggers = 10;
GuiImage * image; //!< Button image (default)
GuiImage * imageOver; //!< Button image for STATE_SELECTED
GuiImage * imageHold; //!< Button image for STATE_HELD
GuiImage * imageClick; //!< Button image for STATE_CLICKED
GuiImage * icon;
GuiImage * iconOver;
GuiText * label[4]; //!< Label(s) to display (default)
GuiText * labelOver[4]; //!< Label(s) to display for STATE_SELECTED
GuiText * labelHold[4]; //!< Label(s) to display for STATE_HELD
GuiText * labelClick[4]; //!< Label(s) to display for STATE_CLICKED
GuiSound * soundOver; //!< Sound to play for STATE_SELECTED
GuiSound * soundHold; //!< Sound to play for STATE_HELD
GuiSound * soundClick; //!< Sound to play for STATE_CLICKED
GuiTrigger * trigger[iMaxGuiTriggers]; //!< GuiTriggers (input actions) that this element responds to
GuiTrigger * clickedTrigger;
GuiTrigger * heldTrigger;
GuiImage *image; //!< Button image (default)
GuiImage *imageOver; //!< Button image for STATE_SELECTED
GuiImage *imageHold; //!< Button image for STATE_HELD
GuiImage *imageClick; //!< Button image for STATE_CLICKED
GuiImage *icon;
GuiImage *iconOver;
GuiText *label[4]; //!< Label(s) to display (default)
GuiText *labelOver[4]; //!< Label(s) to display for STATE_SELECTED
GuiText *labelHold[4]; //!< Label(s) to display for STATE_HELD
GuiText *labelClick[4]; //!< Label(s) to display for STATE_CLICKED
GuiSound *soundOver; //!< Sound to play for STATE_SELECTED
GuiSound *soundHold; //!< Sound to play for STATE_HELD
GuiSound *soundClick; //!< Sound to play for STATE_CLICKED
GuiTrigger *trigger[iMaxGuiTriggers]; //!< GuiTriggers (input actions) that this element responds to
GuiTrigger *clickedTrigger;
GuiTrigger *heldTrigger;
};
#endif

16
include/gui/GuiCheckBox.h
View File

@ -26,23 +26,23 @@ class GuiCheckBox : public GuiToggle {
public:
//!Constructor
//!\param checked Checked
GuiCheckBox(GuiImage * background, bool checked, float width = 0.0f,float height= 0.0f);
GuiCheckBox(GuiImage *background, bool checked, float width = 0.0f, float height = 0.0f);
//!Destructor
virtual ~GuiCheckBox();
void setImageBackground(GuiImage* img);
void setImageBackground(GuiImage *img);
void setImageSelected(GuiImage* img);
void setImageSelected(GuiImage *img);
void setImageHighlighted(GuiImage* img);
void setImageHighlighted(GuiImage *img);
protected:
GuiImage * backgroundImg = NULL;
GuiImage * selectedImg = NULL;
GuiImage * highlightedImg = NULL;
GuiImage *backgroundImg = NULL;
GuiImage *selectedImg = NULL;
GuiImage *highlightedImg = NULL;
void update(GuiController * c);
void update(GuiController *c);
};
#endif

38
include/gui/GuiController.h
View File

@ -24,32 +24,32 @@ class GuiController {
public:
//!Constructor
GuiController(int32_t channel)
: chan(channel) {
: chan(channel) {
memset(&lastData, 0, sizeof(lastData));
memset(&data, 0, sizeof(data));
switch(chan) {
default:
case GuiTrigger::CHANNEL_1:
chanIdx = 0;
break;
case GuiTrigger::CHANNEL_2:
chanIdx = 1;
break;
case GuiTrigger::CHANNEL_3:
chanIdx = 2;
break;
case GuiTrigger::CHANNEL_4:
chanIdx = 3;
break;
case GuiTrigger::CHANNEL_5:
chanIdx = 4;
break;
switch (chan) {
default:
case GuiTrigger::CHANNEL_1:
chanIdx = 0;
break;
case GuiTrigger::CHANNEL_2:
chanIdx = 1;
break;
case GuiTrigger::CHANNEL_3:
chanIdx = 2;
break;
case GuiTrigger::CHANNEL_4:
chanIdx = 3;
break;
case GuiTrigger::CHANNEL_5:
chanIdx = 4;
break;
}
}
//!Destructor
virtual ~GuiController() {}
virtual ~GuiController() {}
virtual bool update(int32_t width, int32_t height) = 0;

11
include/gui/GuiDragListener.h
View File

@ -27,7 +27,8 @@ public:
//!Constructor
//!\param w Width
//!\param h Height
GuiDragListener(float w,float h);
GuiDragListener(float w, float h);
//!Destructor
virtual ~GuiDragListener();
@ -36,17 +37,17 @@ public:
//!Set a new GuiTrigger for the element
//!\param i Index of trigger array to set
//!\param t Pointer to GuiTrigger
void setTrigger(GuiTrigger * t, int32_t idx = -1);
void setTrigger(GuiTrigger *t, int32_t idx = -1);
//!Constantly called to allow the GuiDragListener to respond to updated input data
//!\param t Pointer to a GuiTrigger, containing the current input data from PAD/WPAD
void update(GuiController * c);
void update(GuiController *c);
sigslot::signal5<GuiDragListener *, const GuiController *, GuiTrigger *,int32_t,int32_t> dragged;
sigslot::signal5<GuiDragListener *, const GuiController *, GuiTrigger *, int32_t, int32_t> dragged;
protected:
static const int32_t iMaxGuiTriggers = 10;
GuiTrigger * trigger[iMaxGuiTriggers]; //!< GuiTriggers (input actions) that this element responds to
GuiTrigger *trigger[iMaxGuiTriggers]; //!< GuiTriggers (input actions) that this element responds to
};
#endif

181
include/gui/GuiElement.h
View File

@ -36,34 +36,35 @@
enum {
EFFECT_NONE = 0x00,
EFFECT_SLIDE_TOP = 0x01,
EFFECT_SLIDE_BOTTOM = 0x02,
EFFECT_SLIDE_RIGHT = 0x04,
EFFECT_SLIDE_LEFT = 0x08,
EFFECT_SLIDE_IN = 0x10,
EFFECT_SLIDE_OUT = 0x20,
EFFECT_SLIDE_FROM = 0x40,
EFFECT_FADE = 0x80,
EFFECT_SCALE = 0x100,
EFFECT_COLOR_TRANSITION = 0x200
EFFECT_NONE = 0x00,
EFFECT_SLIDE_TOP = 0x01,
EFFECT_SLIDE_BOTTOM = 0x02,
EFFECT_SLIDE_RIGHT = 0x04,
EFFECT_SLIDE_LEFT = 0x08,
EFFECT_SLIDE_IN = 0x10,
EFFECT_SLIDE_OUT = 0x20,
EFFECT_SLIDE_FROM = 0x40,
EFFECT_FADE = 0x80,
EFFECT_SCALE = 0x100,
EFFECT_COLOR_TRANSITION = 0x200
};
enum {
ALIGN_LEFT = 0x01,
ALIGN_CENTER = 0x02,
ALIGN_RIGHT = 0x04,
ALIGN_TOP = 0x10,
ALIGN_MIDDLE = 0x20,
ALIGN_BOTTOM = 0x40,
ALIGN_TOP_LEFT = ALIGN_LEFT | ALIGN_TOP,
ALIGN_TOP_CENTER = ALIGN_CENTER | ALIGN_TOP,
ALIGN_TOP_RIGHT = ALIGN_RIGHT | ALIGN_TOP,
ALIGN_CENTERED = ALIGN_CENTER | ALIGN_MIDDLE,
ALIGN_LEFT = 0x01,
ALIGN_CENTER = 0x02,
ALIGN_RIGHT = 0x04,
ALIGN_TOP = 0x10,
ALIGN_MIDDLE = 0x20,
ALIGN_BOTTOM = 0x40,
ALIGN_TOP_LEFT = ALIGN_LEFT | ALIGN_TOP,
ALIGN_TOP_CENTER = ALIGN_CENTER | ALIGN_TOP,
ALIGN_TOP_RIGHT = ALIGN_RIGHT | ALIGN_TOP,
ALIGN_CENTERED = ALIGN_CENTER | ALIGN_MIDDLE,
};
//!Forward declaration
class GuiController;
class CVideo;
//!Primary GUI class. Most other classes inherit from this class.
@ -71,60 +72,66 @@ class GuiElement {
public:
//!Constructor
GuiElement();
//!Destructor
virtual ~GuiElement() {}
//!Set the element's parent
//!\param e Pointer to parent element
virtual void setParent(GuiElement * e) {
virtual void setParent(GuiElement *e) {
parentElement = e;
}
//!Gets the element's parent
//!\return Pointer to parent element
virtual GuiElement * getParent() {
virtual GuiElement *getParent() {
return parentElement;
}
//!Gets the current leftmost coordinate of the element
//!Considers horizontal alignment, x offset, width, and parent element's GetLeft() / GetWidth() values
//!\return left coordinate
virtual float getLeft();
//!Gets the current topmost coordinate of the element
//!Considers vertical alignment, y offset, height, and parent element's GetTop() / GetHeight() values
//!\return top coordinate
virtual float getTop();
//!Gets the current Z coordinate of the element
//!\return Z coordinate
virtual float getDepth() {
float zParent = 0.0f;
if(parentElement)
if (parentElement)
zParent = parentElement->getDepth();
return zParent+zoffset;
return zParent + zoffset;
}
virtual float getCenterX(void) {
float pCenterX = 0.0f;
if(parentElement)
if (parentElement)
pCenterX = parentElement->getCenterX();
pCenterX += xoffset + xoffsetDyn;
if(alignment & ALIGN_LEFT) {
if (alignment & ALIGN_LEFT) {
float pWidth = 0.0f;
float pScale = 0.0f;
if(parentElement) {
if (parentElement) {
pWidth = parentElement->getWidth();
pScale = parentElement->getScaleX();
}
pCenterX -= pWidth * 0.5f * pScale - width * 0.5f * getScaleX();
} else if(alignment & ALIGN_RIGHT) {
} else if (alignment & ALIGN_RIGHT) {
float pWidth = 0.0f;
float pScale = 0.0f;
if(parentElement) {
if (parentElement) {
pWidth = parentElement->getWidth();
pScale = parentElement->getScaleX();
}
@ -137,26 +144,26 @@ public:
virtual float getCenterY(void) {
float pCenterY = 0.0f;
if(parentElement)
if (parentElement)
pCenterY = parentElement->getCenterY();
pCenterY += yoffset + yoffsetDyn;
if(alignment & ALIGN_TOP) {
if (alignment & ALIGN_TOP) {
float pHeight = 0.0f;
float pScale = 0.0f;
if(parentElement) {
if (parentElement) {
pHeight = parentElement->getHeight();
pScale = parentElement->getScaleY();
}
pCenterY += pHeight * 0.5f * pScale - getHeight() * 0.5f * getScaleY();
} else if(alignment & ALIGN_BOTTOM) {
} else if (alignment & ALIGN_BOTTOM) {
float pHeight = 0.0f;
float pScale = 0.0f;
if(parentElement) {
if (parentElement) {
pHeight = parentElement->getHeight();
pScale = parentElement->getScaleY();
}
@ -165,24 +172,29 @@ public:
}
return pCenterY;
}
//!Gets elements xoffset
virtual float getOffsetX() {
return xoffset;
}
//!Gets elements yoffset
virtual float getOffsetY() {
return yoffset;
}
//!Gets the current width of the element. Does not currently consider the scale
//!\return width
virtual float getWidth() {
return width;
};
//!Gets the height of the element. Does not currently consider the scale
//!\return height
virtual float getHeight() {
return height;
}
//!Sets the size (width/height) of the element
//!\param w Width of element
//!\param h Height of element
@ -190,124 +202,143 @@ public:
width = w;
height = h;
}
//!Sets the element's visibility
//!\param v Visibility (true = visible)
virtual void setVisible(bool v) {
visible = v;
visibleChanged(this, v);
}
//!Checks whether or not the element is visible
//!\return true if visible, false otherwise
virtual bool isVisible() const {
return !isStateSet(STATE_HIDDEN) && visible;
};
//!Checks whether or not the element is selectable
//!\return true if selectable, false otherwise
virtual bool isSelectable() {
return !isStateSet(STATE_DISABLED) && selectable;
}
virtual bool isDrawOverOnlyWhenSelected() {
return drawOverOnlyWhenSelected;
}
virtual void setdrawOverOnlyWhenSelected(bool s) {
drawOverOnlyWhenSelected = s;
}
//!Checks whether or not the element is clickable
//!\return true if clickable, false otherwise
virtual bool isClickable() {
return !isStateSet(STATE_DISABLED) && clickable;
}
//!Checks whether or not the element is holdable
//!\return true if holdable, false otherwise
virtual bool isHoldable() {
return !isStateSet(STATE_DISABLED) && holdable;
}
//!Sets whether or not the element is selectable
//!\param s Selectable
virtual void setSelectable(bool s) {
selectable = s;
}
//!Sets whether or not the element is clickable
//!\param c Clickable
virtual void setClickable(bool c) {
clickable = c;
}
//!Sets whether or not the element is holdable
//!\param c Holdable
virtual void setHoldable(bool d) {
holdable = d;
}
//!Sets the element's state
//!\param s State (STATE_DEFAULT, STATE_SELECTED, STATE_CLICKED, STATE_DISABLED)
//!\param c Controller channel (0-3, -1 = none)
virtual void setState(int32_t s, int32_t c = -1) {
if(c >= 0 && c < 5) {
if (c >= 0 && c < 5) {
state[c] |= s;
} else {
for(int32_t i = 0; i < 5; i++)
for (int32_t i = 0; i < 5; i++)
state[i] |= s;
}
stateChan = c;
stateChanged(this, s, c);
}
virtual void clearState(int32_t s, int32_t c = -1) {
if(c >= 0 && c < 5) {
if (c >= 0 && c < 5) {
state[c] &= ~s;
} else {
for(int32_t i = 0; i < 5; i++)
for (int32_t i = 0; i < 5; i++)
state[i] &= ~s;
}
stateChan = c;
stateChanged(this, s, c);
}
virtual bool isStateSet(int32_t s, int32_t c = -1) const {
if(c >= 0 && c < 5) {
if (c >= 0 && c < 5) {
return (state[c] & s) != 0;
} else {
for(int32_t i = 0; i < 5; i++)
if((state[i] & s) != 0)
for (int32_t i = 0; i < 5; i++)
if ((state[i] & s) != 0)
return true;
return false;
}
}
//!Gets the element's current state
//!\return state
virtual int32_t getState(int32_t c = 0) {
return state[c];
};
//!Gets the controller channel that last changed the element's state
//!\return Channel number (0-3, -1 = no channel)
virtual int32_t getStateChan() {
return stateChan;
};
//!Resets the element's state to STATE_DEFAULT
virtual void resetState() {
for(int32_t i = 0; i < 5; i++)
for (int32_t i = 0; i < 5; i++)
state[i] = STATE_DEFAULT;
stateChan = -1;
}
//!Sets the element's alpha value
//!\param a alpha value
virtual void setAlpha(float a) {
alpha = a;
}
//!Gets the element's alpha value
//!Considers alpha, alphaDyn, and the parent element's getAlpha() value
//!\return alpha
virtual float getAlpha() {
float a;
if(alphaDyn >= 0)
if (alphaDyn >= 0)
a = alphaDyn;
else
a = alpha;
if(parentElement)
if (parentElement)
a = (a * parentElement->getAlpha());
return a;
}
//!Sets the element's scale
//!\param s scale (1 is 100%)
virtual void setScale(float s) {
@ -315,106 +346,123 @@ public:
scaleY = s;
scaleZ = s;
}
//!Sets the element's scale
//!\param s scale (1 is 100%)
virtual void setScaleX(float s) {
scaleX = s;
}
//!Sets the element's scale
//!\param s scale (1 is 100%)
virtual void setScaleY(float s) {
scaleY = s;
}
//!Sets the element's scale
//!\param s scale (1 is 100%)
virtual void setScaleZ(float s) {
scaleZ = s;
}
//!Gets the element's current scale
//!Considers scale, scaleDyn, and the parent element's getScale() value
virtual float getScale() {
float s = 0.5f * (scaleX+scaleY) * scaleDyn;
float s = 0.5f * (scaleX + scaleY) * scaleDyn;
if(parentElement)
if (parentElement)
s *= parentElement->getScale();
return s;
}
//!Gets the element's current scale
//!Considers scale, scaleDyn, and the parent element's getScale() value
virtual float getScaleX() {
float s = scaleX * scaleDyn;
if(parentElement)
if (parentElement)
s *= parentElement->getScaleX();
return s;
}
//!Gets the element's current scale
//!Considers scale, scaleDyn, and the parent element's getScale() value
virtual float getScaleY() {
float s = scaleY * scaleDyn;
if(parentElement)
if (parentElement)
s *= parentElement->getScaleY();
return s;
}
//!Gets the element's current scale
//!Considers scale, scaleDyn, and the parent element's getScale() value
virtual float getScaleZ() {
float s = scaleZ;
if(parentElement)
if (parentElement)
s *= parentElement->getScaleZ();
return s;
}
//!Checks whether rumble was requested by the element
//!\return true is rumble was requested, false otherwise
virtual bool isRumbleActive() {
return rumble;
}
//!Sets whether or not the element is requesting a rumble event
//!\param r true if requesting rumble, false if not
virtual void setRumble(bool r) {
rumble = r;
}
//!Set an effect for the element
//!\param e Effect to enable
//!\param a Amount of the effect (usage varies on effect)
//!\param t Target amount of the effect (usage varies on effect)
virtual void setEffect(int32_t e, int32_t a, int32_t t=0);
virtual void setEffect(int32_t e, int32_t a, int32_t t = 0);
//!Sets an effect to be enabled on wiimote cursor over
//!\param e Effect to enable
//!\param a Amount of the effect (usage varies on effect)
//!\param t Target amount of the effect (usage varies on effect)
virtual void setEffectOnOver(int32_t e, int32_t a, int32_t t=0);
virtual void setEffectOnOver(int32_t e, int32_t a, int32_t t = 0);
//!Shortcut to SetEffectOnOver(EFFECT_SCALE, 4, 110)
virtual void setEffectGrow() {
setEffectOnOver(EFFECT_SCALE, 4, 110);
}
//!Reset all applied effects
virtual void resetEffects();
//!Gets the current element effects
//!\return element effects
virtual int32_t getEffect() const {
return effects;
}
//!\return true if element animation is on going
virtual bool isAnimated() const {
return (parentElement != 0) && (getEffect() > 0);
}
//!Checks whether the specified coordinates are within the element's boundaries
//!\param x X coordinate
//!\param y Y coordinate
//!\return true if contained within, false otherwise
virtual bool isInside(float x, float y) {
return ( x > (this->getCenterX() - getScaleX() * getWidth() * 0.5f)
&& x < (this->getCenterX() + getScaleX() * getWidth() * 0.5f)
&& y > (this->getCenterY() - getScaleY() * getHeight() * 0.5f)
&& y < (this->getCenterY() + getScaleY() * getHeight() * 0.5f));
return (x > (this->getCenterX() - getScaleX() * getWidth() * 0.5f)
&& x < (this->getCenterX() + getScaleX() * getWidth() * 0.5f)
&& y > (this->getCenterY() - getScaleY() * getHeight() * 0.5f)
&& y < (this->getCenterY() + getScaleY() * getHeight() * 0.5f));
}
//!Sets the element's position
//!\param x X coordinate
//!\param y Y coordinate
@ -422,6 +470,7 @@ public:
xoffset = x;
yoffset = y;
}
//!Sets the element's position
//!\param x X coordinate
//!\param y Y coordinate
@ -431,38 +480,46 @@ public:
yoffset = y;
zoffset = z;
}
//!Gets whether or not the element is in STATE_SELECTED
//!\return true if selected, false otherwise
virtual int32_t getSelected() {
return -1;
}
//!Sets the element's alignment respective to its parent element
//!Bitwise ALIGN_LEFT | ALIGN_RIGHT | ALIGN_CENTRE, ALIGN_TOP, ALIGN_BOTTOM, ALIGN_MIDDLE)
//!\param align Alignment
virtual void setAlignment(int32_t a) {
alignment = a;
}
//!Gets the element's alignment
virtual int32_t getAlignment() const {
return alignment;
}
//!Angle of the object
virtual void setAngle(float a) {
angle = a;
}
//!Angle of the object
virtual float getAngle() const {
float r_angle = angle;
if(parentElement) r_angle += parentElement->getAngle();
if (parentElement) r_angle += parentElement->getAngle();
return r_angle;
}
//!Called constantly to allow the element to respond to the current input data
//!\param t Pointer to a GuiController, containing the current input data from PAD/WPAD/VPAD
virtual void update(GuiController * t) { }
virtual void update(GuiController *t) {}
//!Called constantly to redraw the element
virtual void draw(CVideo * v) { }
virtual void draw(CVideo *v) {}
//!Called constantly to process stuff in the element
virtual void process() { }
virtual void process() {}
//!Updates the element's effects (dynamic values)
//!Called by Draw(), used for animation purposes
@ -491,12 +548,14 @@ public:
//POINT r = { p.x + getLeft(), p.y + getTop() };
return p;
}
//! Switch pointer screen to control position
POINT PtrToControl(POINT p) {
//! TODO for 3D
//POINT r = { p.x - getLeft(), p.y - getTop() };
return p;
}
//! Signals
sigslot::signal2<GuiElement *, bool> visibleChanged;
sigslot::signal3<GuiElement *, int32_t, int32_t> stateChanged;
@ -521,7 +580,7 @@ protected:
int32_t alignment; //!< Horizontal element alignment, respective to parent element
int32_t state[5]; //!< Element state (DEFAULT, SELECTED, CLICKED, DISABLED)
int32_t stateChan; //!< Which controller channel is responsible for the last change in state
GuiElement * parentElement; //!< Parent element
GuiElement *parentElement; //!< Parent element
//! TODO: Move me to some Animator class
int32_t xoffsetDyn; //!< Element X offset, dynamic (added to xoffset value for animation effects)

38
include/gui/GuiFrame.h
View File

@ -26,75 +26,99 @@ class GuiFrame : public GuiElement {
public:
//!Constructor
GuiFrame(GuiFrame *parent = 0);
//!\overload
//!\param w Width of window
//!\param h Height of window
GuiFrame(float w, float h, GuiFrame *parent = 0);
//!Destructor
virtual ~GuiFrame();
//!Appends a GuiElement to the GuiFrame
//!\param e The GuiElement to append. If it is already in the GuiFrame, it is removed first
void append(GuiElement* e);
void append(GuiElement *e);
//!Inserts a GuiElement into the GuiFrame at the specified index
//!\param e The GuiElement to insert. If it is already in the GuiFrame, it is removed first
//!\param i Index in which to insert the element
void insert(GuiElement* e, uint32_t i);
void insert(GuiElement *e, uint32_t i);
//!Removes the specified GuiElement from the GuiFrame
//!\param e GuiElement to be removed
void remove(GuiElement* e);
void remove(GuiElement *e);
//!Removes all GuiElements
void removeAll();
//!Bring element to front of the window
void bringToFront(GuiElement *e) {
remove(e);
append(e);
}
//!Returns the GuiElement at the specified index
//!\param index The index of the element
//!\return A pointer to the element at the index, NULL on error (eg: out of bounds)
GuiElement* getGuiElementAt(uint32_t index) const;
GuiElement *getGuiElementAt(uint32_t index) const;
//!Returns the size of the list of elements
//!\return The size of the current element list
uint32_t getSize();
//!Sets the visibility of the window
//!\param v visibility (true = visible)
void setVisible(bool v);
//!Resets the window's state to STATE_DEFAULT
void resetState();
//!Sets the window's state
//!\param s State
void setState(int32_t s, int32_t c = -1);
void clearState(int32_t s, int32_t c = -1);
//!Gets the index of the GuiElement inside the window that is currently selected
//!\return index of selected GuiElement
int32_t getSelected();
//!Dim the Window's background
void dimBackground(bool d);
//!Draws all the elements in this GuiFrame
void draw(CVideo * v);
void draw(CVideo *v);
//!Updates the window and all elements contains within
//!Allows the GuiFrame and all elements to respond to the input data specified
//!\param t Pointer to a GuiTrigger, containing the current input data from PAD/WPAD
void update(GuiController * t);
void update(GuiController *t);
//!virtual Close Window - this will put the object on the delete queue in MainWindow
virtual void close();
//!virtual show window function
virtual void show() {}
//!virtual hide window function
virtual void hide() {}
//!virtual enter main loop function (blocking)
virtual void exec() {}
//!virtual updateEffects which is called by the main loop
virtual void updateEffects();
//!virtual process which is called by the main loop
virtual void process();
//! Signals
//! On Closing
sigslot::signal1<GuiFrame *> closing;
protected:
bool dim; //! Enable/disable dim of a window only
GuiFrame *parent; //!< Parent Window
std::vector<GuiElement*> elements; //!< Contains all elements within the GuiFrame
std::vector<GuiElement *> elements; //!< Contains all elements within the GuiFrame
};
#endif

38
include/gui/GuiImage.h
View File

@ -32,65 +32,79 @@ public:
//!\overload
//!\param img Pointer to GuiImageData element
GuiImage(GuiImageData * img);
GuiImage(GuiImageData *img);
//!\overload
//!Creates an image filled with the specified color
//!\param w Image width
//!\param h Image height
//!\param c Array with 4 x image color (BL, BR, TL, TR)
GuiImage(int32_t w, int32_t h, const GX2Color & c, int32_t imgType = IMAGE_COLOR);
GuiImage(int32_t w, int32_t h, const GX2Color * c, uint32_t colorCount = 1, int32_t imgType = IMAGE_COLOR);
GuiImage(int32_t w, int32_t h, const GX2Color &c, int32_t imgType = IMAGE_COLOR);
GuiImage(int32_t w, int32_t h, const GX2Color *c, uint32_t colorCount = 1, int32_t imgType = IMAGE_COLOR);
//!Destructor
virtual ~GuiImage();
//!Sets the number of times to draw the image horizontally
//!\param t Number of times to draw the image
void setTileHorizontal(int32_t t) {
tileHorizontal = t;
}
//!Sets the number of times to draw the image vertically
//!\param t Number of times to draw the image
void setTileVertical(int32_t t) {
tileVertical = t;
}
//!Constantly called to draw the image
void draw(CVideo *pVideo);
//!Gets the image data
//!\return pointer to image data
GuiImageData * getImageData() const {
GuiImageData *getImageData() const {
return imageData;
}
//!Sets up a new image using the GuiImageData object specified
//!\param img Pointer to GuiImageData object
void setImageData(GuiImageData * img);
void setImageData(GuiImageData *img);
//!Gets the pixel color at the specified coordinates of the image
//!\param x X coordinate
//!\param y Y coordinate
GX2Color getPixel(int32_t x, int32_t y);
//!Sets the pixel color at the specified coordinates of the image
//!\param x X coordinate
//!\param y Y coordinate
//!\param color Pixel color
void setPixel(int32_t x, int32_t y, const GX2Color & color);
void setPixel(int32_t x, int32_t y, const GX2Color &color);
//!Change ImageColor
void setImageColor(const GX2Color & c, int32_t idx = -1);
void setImageColor(const GX2Color &c, int32_t idx = -1);
//!Change ImageColor
void setSize(int32_t w, int32_t h);
void setPrimitiveVertex(int32_t prim, const float *pos, const float *tex, uint32_t count);
void setBlurDirection(uint8_t dir, float value) {
if(dir < 2) {
if (dir < 2) {
blurDirection[dir] = value;
}
}
void setColorIntensity(const glm::vec4 & col) {
void setColorIntensity(const glm::vec4 &col) {
colorIntensity = col;
}
protected:
void internalInit(int32_t w, int32_t h);
int32_t imgType; //!< Type of image data (IMAGE_TEXTURE, IMAGE_COLOR, IMAGE_DATA)
GuiImageData * imageData; //!< Poiner to image data. May be shared with GuiImageData data
GuiImageData *imageData; //!< Poiner to image data. May be shared with GuiImageData data
int32_t tileHorizontal; //!< Number of times to draw (tile) the image horizontally
int32_t tileVertical; //!< Number of times to draw (tile) the image vertically
@ -104,8 +118,8 @@ protected:
float imageAngle;
glm::vec3 blurDirection;
const float * posVtxs;
const float * texCoords;
const float *posVtxs;
const float *texCoords;
uint32_t vtxCount;
int32_t primitive;
};

20
include/gui/GuiImageAsync.h
View File

@ -24,17 +24,21 @@
class GuiImageAsync : public GuiImage {
public:
GuiImageAsync(const uint8_t *imageBuffer, const uint32_t & imageBufferSize, GuiImageData * preloadImg);
GuiImageAsync(const std::string & filename, GuiImageData * preloadImg);
GuiImageAsync(const uint8_t *imageBuffer, const uint32_t &imageBufferSize, GuiImageData *preloadImg);
GuiImageAsync(const std::string &filename, GuiImageData *preloadImg);
virtual ~GuiImageAsync();
static void clearQueue();
static void removeFromQueue(GuiImageAsync * image) {
static void removeFromQueue(GuiImageAsync *image) {
threadRemoveImage(image);
}
//! don't forget to LOCK GUI if using this asynchron call
sigslot::signal1<GuiImageAsync *> imageLoaded;
static void threadExit();
private:
@ -46,14 +50,16 @@ private:
const uint32_t imgBufferSize;
static void guiImageAsyncThread(CThread *thread, void *arg);
static void threadAddImage(GuiImageAsync* Image);
static void threadRemoveImage(GuiImageAsync* Image);
static void threadAddImage(GuiImageAsync *Image);
static void threadRemoveImage(GuiImageAsync *Image);
static std::vector<GuiImageAsync *> imageQueue;
static CThread *pThread;
static std::recursive_mutex * pMutex;
static std::recursive_mutex *pMutex;
static uint32_t threadRefCounter;
static GuiImageAsync * pInUse;
static GuiImageAsync *pInUse;
static bool bExitRequested;
};

22
include/gui/GuiImageData.h
View File

@ -26,38 +26,48 @@ class GuiImageData : public GuiElement {
public:
//!Constructor
GuiImageData();
//!\param img Image data
//!\param imgSize The image size
GuiImageData(const uint8_t * img, int32_t imgSize, GX2TexClampMode textureClamp = GX2_TEX_CLAMP_MODE_CLAMP, GX2SurfaceFormat textureFormat = GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8);
GuiImageData(const uint8_t *img, int32_t imgSize, GX2TexClampMode textureClamp = GX2_TEX_CLAMP_MODE_CLAMP, GX2SurfaceFormat textureFormat = GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8);
//!Destructor
virtual ~GuiImageData();
//!Load image from buffer
//!\param img Image data
//!\param imgSize The image size
void loadImage(const uint8_t * img, int32_t imgSize, GX2TexClampMode textureClamp = GX2_TEX_CLAMP_MODE_CLAMP, GX2SurfaceFormat textureFormat = GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8);
void loadImage(const uint8_t *img, int32_t imgSize, GX2TexClampMode textureClamp = GX2_TEX_CLAMP_MODE_CLAMP, GX2SurfaceFormat textureFormat = GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8);
//! getter functions
const GX2Texture * getTexture() const {
const GX2Texture *getTexture() const {
return texture;
};
const GX2Sampler * getSampler() const {
const GX2Sampler *getSampler() const {
return sampler;
};
//!Gets the image width
//!\return image width
int32_t getWidth() const {
if(texture) return texture->surface.width;
if (texture) return texture->surface.width;
else return 0;
};
//!Gets the image height
//!\return image height
int32_t getHeight() const {
if(texture) return texture->surface.height;
if (texture) return texture->surface.height;
else return 0;
};
//! release memory of the image data
void releaseData(void);
private:
void gdImageToUnormR8G8B8A8(gdImagePtr gdImg, uint32_t *imgBuffer, uint32_t width, uint32_t height, uint32_t pitch);
void gdImageToUnormR5G6B5(gdImagePtr gdImg, uint16_t *imgBuffer, uint32_t width, uint32_t height, uint32_t pitch);
GX2Texture *texture;

2
include/gui/GuiParticleImage.h
View File

@ -22,9 +22,11 @@
class GuiParticleImage : public GuiImage, public sigslot::has_slots<> {
public:
GuiParticleImage(int32_t w, int32_t h, uint32_t particleCount, float minRadius, float maxRadius, float minSpeed, float maxSpeed);
virtual ~GuiParticleImage();
void draw(CVideo *pVideo);
private:
float *posVertexs;
uint8_t *colorVertexs;

54
include/gui/GuiScrollbar.h
View File

@ -30,38 +30,51 @@
class GuiScrollbar : public GuiElement, public sigslot::has_slots<> {
public:
GuiScrollbar(int32_t height);
virtual ~GuiScrollbar();
void ScrollOneUp();
void ScrollOneDown();
int32_t GetSelectedItem() {
return SelItem;
}
int32_t GetSelectedIndex() {
return SelInd;
}
void draw(CVideo * video);
void update(GuiController * t);
void draw(CVideo *video);
void update(GuiController *t);
//! Signals
sigslot::signal2<int32_t, int32_t> listChanged;
//! Slots
void SetScrollSpeed(int32_t speed) {
ScrollSpeed = speed;
};
void SetPageSize(int32_t size);
void SetRowSize(int32_t size);
void SetSelectedItem(int32_t pos);
void SetSelectedIndex(int32_t pos);
void SetEntrieCount(int32_t cnt);
void setSoundClick(GuiSound * snd) {
void setSoundClick(GuiSound *snd) {
clickSound = snd;
arrowUpBtn->setSoundClick(snd);
arrowDownBtn->setSoundClick(snd);
}
void setImageScrollbarLine(GuiImage * img) {
if(img) {
void setImageScrollbarLine(GuiImage *img) {
if (img) {
scrollbarLineImage = img;
scrollbarLineImage->setParent(this);
scrollbarLineImage->setParent(this);
@ -70,24 +83,24 @@ public:
}
}
void setImageArrowDown(GuiImage * img) {
if(img) {
void setImageArrowDown(GuiImage *img) {
if (img) {
arrowDownImage = img;
arrowDownBtn->setSize(img->getWidth(), img->getHeight());
arrowDownBtn->setImage(img);
}
}
void setImageArrowUp(GuiImage * img) {
if(img) {
void setImageArrowUp(GuiImage *img) {
if (img) {
arrowUpImage = img;
arrowUpBtn->setSize(img->getWidth(), img->getHeight());
arrowUpBtn->setImage(img);
}
}
void setImageScrollbarBox(GuiImage * img) {
if(img) {
void setImageScrollbarBox(GuiImage *img) {
if (img) {
scrollbarBoxImage = img;
scrollbarBoxBtn->setSize(img->getWidth(), height);
scrollbarBoxBtn->setImage(img);
@ -101,8 +114,11 @@ public:
protected:
void setScrollboxPosition(int32_t SelItem, int32_t SelInd);
void OnUpButtonClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
void OnDownButtonClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
void OnBoxButtonHold(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
uint32_t ScrollState;
@ -116,16 +132,16 @@ protected:
int32_t EntrieCount;
int32_t pressedChan;
GuiButton * arrowUpBtn;
GuiButton * arrowDownBtn;
GuiButton * scrollbarBoxBtn;
GuiButton *arrowUpBtn;
GuiButton *arrowDownBtn;
GuiButton *scrollbarBoxBtn;
GuiSound * clickSound = NULL;
GuiSound *clickSound = NULL;
GuiImage * scrollbarLineImage = NULL;
GuiImage * arrowDownImage = NULL;
GuiImage * arrowUpImage = NULL;
GuiImage * scrollbarBoxImage = NULL;
GuiImage *scrollbarLineImage = NULL;
GuiImage *arrowDownImage = NULL;
GuiImage *arrowUpImage = NULL;
GuiImage *scrollbarBoxImage = NULL;
GuiTrigger touchTrigger;
GuiTrigger wpadTouchTrigger;

42
include/gui/GuiSelectBox.h
View File

@ -26,62 +26,72 @@ class GuiSelectBox : public GuiFrame, public sigslot::has_slots<> {
public:
//!Constructor
//!\param checked Checked
GuiSelectBox(GuiImage * background, std::string caption,float width = 0.0f, float height = 0.0f,GuiFrame *parent = 0);
GuiSelectBox(GuiImage *background, std::string caption, float width = 0.0f, float height = 0.0f, GuiFrame *parent = 0);
//!Destructor
virtual ~GuiSelectBox();
sigslot::signal2<GuiSelectBox *, std::string> valueChanged;
sigslot::signal2<GuiSelectBox *, bool> showhide;
void setImageTopBackground(GuiImage * img) {
void setImageTopBackground(GuiImage *img) {
topBackgroundImg = img;
topValueButton.setImage(img);
}
void setImageTopHighlighted(GuiImage * img) {
void setImageTopHighlighted(GuiImage *img) {
topHighlightedImg = img;
topValueButton.setIconOver(img);
}
void setImageValueBackground(GuiImageData * img) {
void setImageValueBackground(GuiImageData *img) {
valueImageData = img;
}
void setImageValueHighlighted(GuiImageData * img) {
void setImageValueHighlighted(GuiImageData *img) {
valueHighlightedImageData = img;
}
void setImageValueSelected(GuiImageData * img) {
void setImageValueSelected(GuiImageData *img) {
valueSelectedImageData = img;
}
void setSoundClick(GuiSound * snd) {
void setSoundClick(GuiSound *snd) {
buttonClickSound = snd;
topValueButton.setSoundClick(snd);
}
void OnTopValueClicked(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
void Init(std::map<std::string,std::string> values, int32_t valueID);
void Init(std::map<std::string, std::string> values, int32_t valueID);
void setState(int32_t s, int32_t c = -1);
virtual void setSize(float width, float height);
virtual float getTopValueHeight();
virtual float getTopValueWidth();
virtual float getHeight();
virtual float getWidth();
protected:
void DeleteValueData();
void update(GuiController * c);
void update(GuiController *c);
void OnValueClicked(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
void OnDPADClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
void OnValueOpenEffectFinish(GuiElement *element);
void OnValueCloseEffectFinish(GuiElement *element);
void ShowHideValues(bool showhide);
void SelectValue(uint32_t value);
uint32_t selected;
@ -91,13 +101,13 @@ protected:
bool opened;
std::string captionText;
GuiFrame valuesFrame;
GuiImage* topBackgroundImg = NULL;
GuiImage* topHighlightedImg = NULL;
GuiImage *topBackgroundImg = NULL;
GuiImage *topHighlightedImg = NULL;
GuiButton topValueButton;
GuiImageData * valueImageData = NULL;
GuiImageData * valueSelectedImageData = NULL;
GuiImageData * valueHighlightedImageData = NULL;
GuiImageData *valueImageData = NULL;
GuiImageData *valueSelectedImageData = NULL;
GuiImageData *valueHighlightedImageData = NULL;
GuiText topValueText;
GuiTrigger touchTrigger;
@ -112,7 +122,7 @@ protected:
GuiButton DPADButtons;
GuiSound* buttonClickSound;
GuiSound *buttonClickSound;
typedef struct {
GuiImage *valueButtonImg;
@ -122,7 +132,7 @@ protected:
GuiText *valueButtonText;
} SelectBoxValueButton;
std::map<GuiButton * ,std::string> buttonToValue;
std::map<GuiButton *, std::string> buttonToValue;
std::vector<SelectBoxValueButton> valueButtons;
};

21
include/gui/GuiSound.h
View File

@ -25,32 +25,45 @@ public:
//!Constructor
//!\param sound Pointer to the sound data
//!\param filesize Length of sound data
GuiSound(const char * filepath);
GuiSound(const uint8_t * sound, int32_t length);
GuiSound(const char *filepath);
GuiSound(const uint8_t *sound, int32_t length);
//!Destructor
virtual ~GuiSound();
//!Load a file and replace the old one
bool Load(const char * filepath);
bool Load(const char *filepath);
//!Load a file and replace the old one
bool Load(const uint8_t * snd, int32_t len);
bool Load(const uint8_t *snd, int32_t len);
//!Start sound playback
void Play();
//!Stop sound playback
void Stop();
//!Pause sound playback
void Pause();
//!Resume sound playback
void Resume();
//!Checks if the sound is currently playing
//!\return true if sound is playing, false otherwise
bool IsPlaying();
//!Rewind the music
void Rewind();
//!Set sound volume
//!\param v Sound volume (0-100)
void SetVolume(uint32_t v);
//!\param l Loop (true to loop)
void SetLoop(bool l);
protected:
int32_t voice; //!< Currently assigned ASND voice channel
};

22
include/gui/GuiSwitch.h
View File

@ -26,25 +26,27 @@ class GuiSwitch : public GuiToggle {
public:
//!Constructor
//!\param checked Checked
GuiSwitch(GuiImage * background, bool checked, float w = 0.0f, float h = 0.0f);
GuiSwitch(GuiImage *background, bool checked, float w = 0.0f, float h = 0.0f);
//!Destructor
virtual ~GuiSwitch();
void setImageBackground(GuiImage* img);
void setImageBackground(GuiImage *img);
void setImageOn(GuiImage* img);
void setImageOn(GuiImage *img);
void setImageOff(GuiImage* img);
void setImageOff(GuiImage *img);
void setImageHighlighted(GuiImage *img);
void setImageHighlighted(GuiImage* img);
protected:
GuiImage * backgroundImg = NULL;
GuiImage * onImg = NULL;
GuiImage * offImg = NULL;
GuiImage * highlightedImg = NULL;
GuiImage *backgroundImg = NULL;
GuiImage *onImg = NULL;
GuiImage *offImg = NULL;
GuiImage *highlightedImg = NULL;
void draw(CVideo * v);
void draw(CVideo *v);
};
#endif

57
include/gui/GuiText.h
View File

@ -18,6 +18,7 @@
#define GUI_TEXT_H_
#include <gui/GuiElement.h>
//!Forward declaration
class FreeTypeGX;
@ -26,26 +27,34 @@ class GuiText : public GuiElement {
public:
//!Constructor
GuiText();
//!\param t Text
//!\param s Font size
//!\param c Font color
GuiText(const char * t, int32_t s, const glm::vec4 & c);
GuiText(const char *t, int32_t s, const glm::vec4 &c);
//!\overload
//!\param t Text
//!\param s Font size
//!\param c Font color
GuiText(const wchar_t * t, int32_t s, const glm::vec4 & c);
GuiText(const wchar_t *t, int32_t s, const glm::vec4 &c);
//!\overload
//!\Assumes SetPresets() has been called to setup preferred text attributes
//!\param t Text
GuiText(const char * t);
GuiText(const char *t);
//!Destructor
virtual ~GuiText();
//!Sets the text of the GuiText element
//!\param t Text
virtual void setText(const char * t);
virtual void setText(const wchar_t * t);
virtual void setTextf(const char *format, ...) __attribute__((format(printf,2,3)));
virtual void setText(const char *t);
virtual void setText(const wchar_t *t);
virtual void setTextf(const char *format, ...) __attribute__((format(printf, 2, 3)));
//!Sets up preset values to be used by GuiText(t)
//!Useful when printing multiple text elements, all with the same attributes set
//!\param sz Font size
@ -53,60 +62,77 @@ public:
//!\param w Maximum width of texture image (for text wrapping)
//!\param wrap Wrapmode when w>0
//!\param a Text alignment
static void setPresets(int32_t sz, const glm::vec4 & c, int32_t w, int32_t a);
static void setPresets(int32_t sz, const glm::vec4 &c, int32_t w, int32_t a);
static void setPresetFont(FreeTypeGX *font);
//!Sets the font size
//!\param s Font size
void setFontSize(int32_t s);
//!Sets the maximum width of the drawn texture image
//!If the text exceeds this, it is wrapped to the next line
//!\param w Maximum width
//!\param m WrapMode
void setMaxWidth(int32_t w = 0, int32_t m = WRAP);
//!Sets the font color
//!\param c Font color
void setColor(const glm::vec4 & c);
void setColor(const glm::vec4 &c);
void setBlurGlowColor(float blurIntensity, const glm::vec4 & c);
void setBlurGlowColor(float blurIntensity, const glm::vec4 &c);
void setTextBlur(float blur) {
defaultBlur = blur;
}
//!Get the original text as char
virtual const wchar_t * getText() const {
virtual const wchar_t *getText() const {
return text;
}
virtual std::string toUTF8(void) const;
//!Get the Horizontal Size of Text
int32_t getTextWidth() {
return textWidth;
}
int32_t getTextWidth(int32_t ind);
//!Get the max textwidth
int32_t getTextMaxWidth() {
return maxWidth;
}
//!Get fontsize
int32_t getFontSize() {
return size;
};
//!Set max lines to draw
void setLinesToDraw(int32_t l) {
linestodraw = l;
}
//!Get current Textline (for position calculation)
const wchar_t * getDynText(int32_t ind = 0);
virtual const wchar_t * getTextLine(int32_t ind) {
const wchar_t *getDynText(int32_t ind = 0);
virtual const wchar_t *getTextLine(int32_t ind) {
return getDynText(ind);
};
//!Change the font
bool setFont(FreeTypeGX *font);
//! virtual function used in child classes
virtual int32_t getStartWidth() {
return 0;
};
//!Constantly called to draw the text
void draw(CVideo *pVideo);
//! text enums
enum {
WRAP,
@ -115,7 +141,7 @@ public:
SCROLL_NONE
};
protected:
static FreeTypeGX * presentFont;
static FreeTypeGX *presentFont;
static int32_t presetSize;
static int32_t presetMaxWidth;
static float presetInternalRenderingScale;
@ -124,14 +150,17 @@ protected:
//!Clear the dynamic text
void clearDynamicText();
//!Create a dynamic dotted text if the text is too long
void makeDottedText();
//!Scroll the text once
void scrollText(uint32_t frameCount);
//!Wrap the text to several lines
void wrapText();
wchar_t * text;
wchar_t *text;
std::vector<wchar_t *> textDyn;
std::vector<uint16_t> textDynWidth;
int32_t wrapMode; //!< Wrapping toggle

67
include/gui/GuiToggle.h
View File

@ -21,39 +21,46 @@
#include <gui/GuiFrame.h>
//!A simple CheckBox
class GuiToggle : public GuiButton, public sigslot::has_slots<>
{
public:
//!Constructor
//!\param checked Checked
GuiToggle(bool checked,float width,float height);
//!Destructor
virtual ~GuiToggle();
void setValue(bool checked){
if(selected != checked){
selected = checked;
bChanged=true;
valueChanged(this,selected);
}
}
void setChecked(){
setValue(true);
class GuiToggle : public GuiButton, public sigslot::has_slots<> {
public:
//!Constructor
//!\param checked Checked
GuiToggle(bool checked, float width, float height);
}
void setUnchecked(){
setValue(false);
}
bool getValue(){
return selected;
}
sigslot::signal2<GuiToggle *, bool> valueChanged;
void OnToggleClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
protected:
//!Destructor
virtual ~GuiToggle();
bool selected;
bool bChanged;
void setValue(bool checked) {
if (selected != checked) {
selected = checked;
bChanged = true;
valueChanged(this, selected);
}
}
void update(GuiController * c);
void setChecked() {
setValue(true);
}
void setUnchecked() {
setValue(false);
}
bool getValue() {
return selected;
}
sigslot::signal2<GuiToggle *, bool> valueChanged;
void OnToggleClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
protected:
bool selected;
bool bChanged;
void update(GuiController *c);
};
#endif

14
include/gui/GuiTrigger.h
View File

@ -68,19 +68,24 @@ public:
//!Constructor
GuiTrigger();
//!Constructor
GuiTrigger(uint32_t ch, uint32_t btns, bool clickEverywhere = false, bool holdEverywhere = false, bool selectionClickEverywhere = false);
//!Destructor
virtual ~GuiTrigger();
//!Sets a simple trigger. Requires: element is selected, and trigger button is pressed
void setTrigger(uint32_t ch, uint32_t btns);
void setClickEverywhere(bool b) {
bClickEverywhere = b;
}
void setHoldOnly(bool b) {
bHoldEverywhere = b;
}
void setSelectionClickEverywhere(bool b) {
bSelectionClickEverywhere = b;
}
@ -88,20 +93,29 @@ public:
bool isClickEverywhere() const {
return bClickEverywhere;
}
bool isHoldEverywhere() const {
return bHoldEverywhere;
}
bool isSelectionClickEverywhere() const {
return bSelectionClickEverywhere;
}
bool left(const GuiController *controller) const;
bool right(const GuiController *controller) const;
bool up(const GuiController *controller) const;
bool down(const GuiController *controller) const;
int32_t clicked(const GuiController *controller) const;
bool held(const GuiController *controller) const;
bool released(const GuiController *controller) const;
private:
uint32_t chan;
uint32_t btns;

10
include/gui/VPadController.h
View File

@ -24,12 +24,12 @@ class VPadController : public GuiController {
public:
//!Constructor
VPadController(int32_t channel)
: GuiController(channel) {
: GuiController(channel) {
memset(&vpad, 0, sizeof(vpad));
}
//!Destructor
virtual ~VPadController() {}
virtual ~VPadController() {}
bool update(int32_t width, int32_t height) {
lastData = data;
@ -37,7 +37,7 @@ public:
VPADReadError vpadError = VPAD_READ_NO_SAMPLES;
VPADRead(VPAD_CHAN_0, &vpad, 1, &vpadError);
if(vpadError == VPAD_READ_SUCCESS) {
if (vpadError == VPAD_READ_SUCCESS) {
data.buttons_r = vpad.release;
data.buttons_h = vpad.hold;
data.buttons_d = vpad.trigger;
@ -47,8 +47,8 @@ public:
VPADGetTPCalibratedPoint(VPAD_CHAN_0, &tpCalib, &vpad.tpFiltered1);
//! calculate the screen offsets
data.x = -(width >> 1) + (int32_t)(((float)tpCalib.x / 1280.0f) * (float)width);
data.y = -(height >> 1) + (int32_t)(float)height - (((float)tpCalib.y / 720.0f) * (float)height);
data.x = -(width >> 1) + (int32_t) (((float) tpCalib.x / 1280.0f) * (float) width);
data.y = -(height >> 1) + (int32_t) (float) height - (((float) tpCalib.y / 720.0f) * (float) height);
return true;
}

79
include/gui/WPadController.h
View File

@ -25,119 +25,120 @@ class WPadController : public GuiController {
public:
//!Constructor
WPadController(int32_t channel)
: GuiController(channel) {
: GuiController(channel) {
memset(&kpadData, 0, sizeof(kpadData));
}
//!Destructor
virtual ~WPadController() {}
virtual ~WPadController() {}
uint32_t remapWiiMoteButtons(uint32_t buttons) {
uint32_t conv_buttons = 0;
if(buttons & WPAD_BUTTON_LEFT)
if (buttons & WPAD_BUTTON_LEFT)
conv_buttons |= GuiTrigger::BUTTON_LEFT;
if(buttons & WPAD_BUTTON_RIGHT)
if (buttons & WPAD_BUTTON_RIGHT)
conv_buttons |= GuiTrigger::BUTTON_RIGHT;
if(buttons & WPAD_BUTTON_DOWN)
if (buttons & WPAD_BUTTON_DOWN)
conv_buttons |= GuiTrigger::BUTTON_DOWN;
if(buttons & WPAD_BUTTON_UP)
if (buttons & WPAD_BUTTON_UP)
conv_buttons |= GuiTrigger::BUTTON_UP;
if(buttons & WPAD_BUTTON_PLUS)
if (buttons & WPAD_BUTTON_PLUS)
conv_buttons |= GuiTrigger::BUTTON_PLUS;
if(buttons & WPAD_BUTTON_2)
if (buttons & WPAD_BUTTON_2)
conv_buttons |= GuiTrigger::BUTTON_2;
if(buttons & WPAD_BUTTON_1)
if (buttons & WPAD_BUTTON_1)
conv_buttons |= GuiTrigger::BUTTON_1;
if(buttons & WPAD_BUTTON_B)
if (buttons & WPAD_BUTTON_B)
conv_buttons |= GuiTrigger::BUTTON_B;
if(buttons & WPAD_BUTTON_A)
if (buttons & WPAD_BUTTON_A)
conv_buttons |= GuiTrigger::BUTTON_A;
if(buttons & WPAD_BUTTON_MINUS)
if (buttons & WPAD_BUTTON_MINUS)
conv_buttons |= GuiTrigger::BUTTON_MINUS;
if(buttons & WPAD_BUTTON_Z)
if (buttons & WPAD_BUTTON_Z)
conv_buttons |= GuiTrigger::BUTTON_Z;
if(buttons & WPAD_BUTTON_C)
if (buttons & WPAD_BUTTON_C)
conv_buttons |= GuiTrigger::BUTTON_C;
if(buttons & WPAD_BUTTON_HOME)
if (buttons & WPAD_BUTTON_HOME)
conv_buttons |= GuiTrigger::BUTTON_HOME;
return conv_buttons;
}
uint32_t remapClassicButtons(uint32_t buttons) {
uint32_t conv_buttons = 0;
if(buttons & WPAD_CLASSIC_BUTTON_LEFT)
if (buttons & WPAD_CLASSIC_BUTTON_LEFT)
conv_buttons |= GuiTrigger::BUTTON_LEFT;
if(buttons & WPAD_CLASSIC_BUTTON_RIGHT)
if (buttons & WPAD_CLASSIC_BUTTON_RIGHT)
conv_buttons |= GuiTrigger::BUTTON_RIGHT;
if(buttons & WPAD_CLASSIC_BUTTON_DOWN)
if (buttons & WPAD_CLASSIC_BUTTON_DOWN)
conv_buttons |= GuiTrigger::BUTTON_DOWN;
if(buttons & WPAD_CLASSIC_BUTTON_UP)
if (buttons & WPAD_CLASSIC_BUTTON_UP)
conv_buttons |= GuiTrigger::BUTTON_UP;
if(buttons & WPAD_CLASSIC_BUTTON_PLUS)
if (buttons & WPAD_CLASSIC_BUTTON_PLUS)
conv_buttons |= GuiTrigger::BUTTON_PLUS;
if(buttons & WPAD_CLASSIC_BUTTON_X)
if (buttons & WPAD_CLASSIC_BUTTON_X)
conv_buttons |= GuiTrigger::BUTTON_X;
if(buttons & WPAD_CLASSIC_BUTTON_Y)
if (buttons & WPAD_CLASSIC_BUTTON_Y)
conv_buttons |= GuiTrigger::BUTTON_Y;
if(buttons & WPAD_CLASSIC_BUTTON_B)
if (buttons & WPAD_CLASSIC_BUTTON_B)
conv_buttons |= GuiTrigger::BUTTON_B;
if(buttons & WPAD_CLASSIC_BUTTON_A)
if (buttons & WPAD_CLASSIC_BUTTON_A)
conv_buttons |= GuiTrigger::BUTTON_A;
if(buttons & WPAD_CLASSIC_BUTTON_MINUS)
if (buttons & WPAD_CLASSIC_BUTTON_MINUS)
conv_buttons |= GuiTrigger::BUTTON_MINUS;
if(buttons & WPAD_CLASSIC_BUTTON_HOME)
if (buttons & WPAD_CLASSIC_BUTTON_HOME)
conv_buttons |= GuiTrigger::BUTTON_HOME;
if(buttons & WPAD_CLASSIC_BUTTON_ZR)
if (buttons & WPAD_CLASSIC_BUTTON_ZR)
conv_buttons |= GuiTrigger::BUTTON_ZR;
if(buttons & WPAD_CLASSIC_BUTTON_ZL)
if (buttons & WPAD_CLASSIC_BUTTON_ZL)
conv_buttons |= GuiTrigger::BUTTON_ZL;
if(buttons & WPAD_CLASSIC_BUTTON_R)
if (buttons & WPAD_CLASSIC_BUTTON_R)
conv_buttons |= GuiTrigger::BUTTON_R;
if(buttons & WPAD_CLASSIC_BUTTON_L)
if (buttons & WPAD_CLASSIC_BUTTON_L)
conv_buttons |= GuiTrigger::BUTTON_L;
return conv_buttons;
}
WPADChan getChanByInt(int32_t chan) {
if(chan == 0) {
if (chan == 0) {
return WPAD_CHAN_0;
}
if(chan == 1) {
if (chan == 1) {
return WPAD_CHAN_1;
}
if(chan == 2) {
if (chan == 2) {
return WPAD_CHAN_3;
}
if(chan == 3) {
if (chan == 3) {
return WPAD_CHAN_3;
}
return WPAD_CHAN_0;
@ -148,12 +149,12 @@ public:
WPADExtensionType controller_type;
//! check if the controller is connected
if(WPADProbe(getChanByInt(chanIdx-1), &controller_type) != 0)
if (WPADProbe(getChanByInt(chanIdx - 1), &controller_type) != 0)
return false;
KPADRead(getChanByInt(chanIdx-1), &kpadData, 1);
KPADRead(getChanByInt(chanIdx - 1), &kpadData, 1);
if(kpadData.extensionType <= 1) {
if (kpadData.extensionType <= 1) {
data.buttons_r = remapWiiMoteButtons(kpadData.release);
data.buttons_h = remapWiiMoteButtons(kpadData.hold);
data.buttons_d = remapWiiMoteButtons(kpadData.trigger);
@ -165,11 +166,11 @@ public:
data.validPointer = (kpadData.posValid == 1 || kpadData.posValid == 2) && (kpadData.pos.x >= -1.0f && kpadData.pos.x <= 1.0f) && (kpadData.pos.y >= -1.0f && kpadData.pos.y <= 1.0f);
//! calculate the screen offsets if pointer is valid else leave old value
if(data.validPointer) {
if (data.validPointer) {
data.x = (width >> 1) * kpadData.pos.x;
data.y = (height >> 1) * (-kpadData.pos.y);
if(kpadData.angle.y > 0.0f)
if (kpadData.angle.y > 0.0f)
data.pointerAngle = (-kpadData.angle.x + 1.0f) * 0.5f * 180.0f;
else
data.pointerAngle = (kpadData.angle.x + 1.0f) * 0.5f * 180.0f - 180.0f;

46
include/gui/gx2_ext.h
View File

@ -1,5 +1,5 @@
#ifndef __GX2_EXTENSION_H
#define __GX2_EXTENSION_H
#define __GX2_EXTENSION_H
#ifdef __cplusplus
extern "C" {
@ -37,22 +37,22 @@ typedef struct _GX2ColorF32 {
} GX2ColorF32;
static const uint32_t attribute_dest_comp_selector[20] = {
GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_X001, GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_X001,
GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW,
GX2_COMP_SEL_XY01, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZ1,
GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW
GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_X001, GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_X001,
GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW,
GX2_COMP_SEL_XY01, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZ1,
GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW
};
static const uint32_t texture_comp_selector[54] = {
GX2_COMP_SEL_NONE, GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_X001,
GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW,
GX2_COMP_SEL_WZYX, GX2_COMP_SEL_X001, GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XY01, GX2_COMP_SEL_NONE,
GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_NONE,
GX2_COMP_SEL_NONE, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_WZYX, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XY01,
GX2_COMP_SEL_XY01, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_NONE, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW,
GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_X001,
GX2_COMP_SEL_XY01, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_XYZ1,
GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01
GX2_COMP_SEL_NONE, GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_X001,
GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW,
GX2_COMP_SEL_WZYX, GX2_COMP_SEL_X001, GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XY01, GX2_COMP_SEL_NONE,
GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_NONE,
GX2_COMP_SEL_NONE, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_WZYX, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XY01,
GX2_COMP_SEL_XY01, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_NONE, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW,
GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_X001,
GX2_COMP_SEL_XY01, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_XYZ1,
GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01
};
static inline void GX2InitDepthBuffer(GX2DepthBuffer *depthBuffer, GX2SurfaceDim dim, uint32_t width, uint32_t height, uint32_t depth, GX2SurfaceFormat format, GX2AAMode aa) {
@ -63,10 +63,10 @@ static inline void GX2InitDepthBuffer(GX2DepthBuffer *depthBuffer, GX2SurfaceDim
depthBuffer->surface.mipLevels = 1;
depthBuffer->surface.format = format;
depthBuffer->surface.aa = aa;
depthBuffer->surface.use = (GX2SurfaceUse)(((format==GX2_SURFACE_FORMAT_UNORM_R24_X8) || (format==GX2_SURFACE_FORMAT_FLOAT_D24_S8)) ?
GX2_SURFACE_USE_DEPTH_BUFFER : (GX2_SURFACE_USE_DEPTH_BUFFER | GX2_SURFACE_USE_TEXTURE));
depthBuffer->surface.use = (GX2SurfaceUse) (((format == GX2_SURFACE_FORMAT_UNORM_R24_X8) || (format == GX2_SURFACE_FORMAT_FLOAT_D24_S8)) ?
GX2_SURFACE_USE_DEPTH_BUFFER : (GX2_SURFACE_USE_DEPTH_BUFFER | GX2_SURFACE_USE_TEXTURE));
depthBuffer->surface.tileMode = GX2_TILE_MODE_DEFAULT;
depthBuffer->surface.swizzle = 0;
depthBuffer->surface.swizzle = 0;
depthBuffer->viewMip = 0;
depthBuffer->viewFirstSlice = 0;
depthBuffer->viewNumSlices = depth;
@ -96,21 +96,21 @@ static inline void GX2InitColorBuffer(GX2ColorBuffer *colorBuffer, GX2SurfaceDim
colorBuffer->surface.alignment = 0;
colorBuffer->surface.pitch = 0;
uint32_t i;
for(i = 0; i < 13; i++)
for (i = 0; i < 13; i++)
colorBuffer->surface.mipLevelOffset[i] = 0;
colorBuffer->viewMip = 0;
colorBuffer->viewFirstSlice = 0;
colorBuffer->viewNumSlices = depth;
colorBuffer->aaBuffer = NULL;
colorBuffer->aaSize = 0;
for(i = 0; i < 5; i++)
for (i = 0; i < 5; i++)
colorBuffer->regs[i] = 0;
GX2CalcSurfaceSizeAndAlignment(&colorBuffer->surface);
GX2InitColorBufferRegs(colorBuffer);
}
static inline void GX2InitAttribStream(GX2AttribStream* attr, uint32_t location, uint32_t buffer, uint32_t offset, GX2AttribFormat format) {
static inline void GX2InitAttribStream(GX2AttribStream *attr, uint32_t location, uint32_t buffer, uint32_t offset, GX2AttribFormat format) {
attr->location = location;
attr->buffer = buffer;
attr->offset = offset;
@ -118,7 +118,7 @@ static inline void GX2InitAttribStream(GX2AttribStream* attr, uint32_t location,
attr->type = GX2_ATTRIB_INDEX_PER_VERTEX;
attr->aluDivisor = 0;
attr->mask = attribute_dest_comp_selector[format & 0xff];
attr->endianSwap = GX2_ENDIAN_SWAP_DEFAULT;
attr->endianSwap = GX2_ENDIAN_SWAP_DEFAULT;
}
static inline void GX2InitTexture(GX2Texture *tex, uint32_t width, uint32_t height, uint32_t depth, uint32_t mipLevels, GX2SurfaceFormat format, GX2SurfaceDim dim, GX2TileMode tile) {
@ -139,14 +139,14 @@ static inline void GX2InitTexture(GX2Texture *tex, uint32_t width, uint32_t heig
tex->surface.alignment = 0;
tex->surface.pitch = 0;
uint32_t i;
for(i = 0; i < 13; i++)
for (i = 0; i < 13; i++)
tex->surface.mipLevelOffset[i] = 0;
tex->viewFirstMip = 0;
tex->viewNumMips = mipLevels;
tex->viewFirstSlice = 0;
tex->viewNumSlices = depth;
tex->compMap = texture_comp_selector[format & 0x3f];
for(i = 0; i < 5; i++)
for (i = 0; i < 5; i++)
tex->regs[i] = 0;
GX2CalcSurfaceSizeAndAlignment(&tex->surface);

10
include/gui/memory.h
View File

@ -24,15 +24,19 @@ extern "C" {
#include <malloc.h>
void libgui_memoryInitialize(void);
void libgui_memoryRelease(void);
void * MEM2_alloc(uint32_t size, uint32_t align);
void *MEM2_alloc(uint32_t size, uint32_t align);
void MEM2_free(void *ptr);
void * MEM1_alloc(uint32_t size, uint32_t align);
void *MEM1_alloc(uint32_t size, uint32_t align);
void MEM1_free(void *ptr);
void * MEMBucket_alloc(uint32_t size, uint32_t align);
void *MEMBucket_alloc(uint32_t size, uint32_t align);
void MEMBucket_free(void *ptr);
#ifdef __cplusplus

4046
include/gui/sigslot.h
View File

File diff suppressed because it is too large Load Diff

35
include/gui/sounds/BufferCircle.hpp
View File

@ -33,55 +33,72 @@ class BufferCircle {
public:
//!> Constructor
BufferCircle();
//!> Destructor
~BufferCircle();
//!> Set circle size
void Resize(int32_t size);
//!> Get the circle size
int32_t Size() {
return SoundBuffer.size();
};
//!> Set/resize the buffer size
void SetBufferBlockSize(int32_t size);
//!> Remove a buffer
void RemoveBuffer(int32_t pos);
//!> Set all buffers clear
void ClearBuffer();
//!> Free all buffers
void FreeBuffer();
//!> Switch to next buffer
void LoadNext();
//!> Get the current buffer
uint8_t * GetBuffer() {
uint8_t *GetBuffer() {
return GetBuffer(which);
};
//!> Get a buffer at a position
uint8_t * GetBuffer(int32_t pos) {
if(!Valid(pos)) return NULL;
uint8_t *GetBuffer(int32_t pos) {
if (!Valid(pos)) return NULL;
else return SoundBuffer[pos];
};
//!> Get current buffer size
uint32_t GetBufferSize() {
return GetBufferSize(which);
};
//!> Get buffer size at position
uint32_t GetBufferSize(int32_t pos) {
if(!Valid(pos)) return 0;
if (!Valid(pos)) return 0;
else return BufferSize[pos];
};
//!> Is current buffer ready
bool IsBufferReady() {
return IsBufferReady(which);
};
//!> Is a buffer at a position ready
bool IsBufferReady(int32_t pos) {
if(!Valid(pos)) return false;
if (!Valid(pos)) return false;
else return BufferReady[pos];
};
//!> Set a buffer at a position to a ready state
void SetBufferReady(int32_t pos, bool st);
//!> Set the buffersize at a position
void SetBufferSize(int32_t pos, int32_t size);
//!> Get the current position in the circle
uint16_t Which() {
return which;
@ -89,12 +106,14 @@ public:
//!> Get the next location
inline uint16_t Next() {
return (which+1 >= Size()) ? 0 : which+1;
return (which + 1 >= Size()) ? 0 : which + 1;
}
inline uint16_t Prev() {
if(Size() == 0) return 0;
else return ((int32_t)which-1 < 0) ? Size()-1 : which-1;
if (Size() == 0) return 0;
else return ((int32_t) which - 1 < 0) ? Size() - 1 : which - 1;
}
protected:
//!> Check if the position is a valid position in the vector
bool Valid(int32_t pos) {

16
include/gui/sounds/Mp3Decoder.hpp
View File

@ -29,18 +29,24 @@
class Mp3Decoder : public SoundDecoder {
public:
Mp3Decoder(const char * filepath);
Mp3Decoder(const uint8_t * sound, int32_t len);
Mp3Decoder(const char *filepath);
Mp3Decoder(const uint8_t *sound, int32_t len);
virtual ~Mp3Decoder();
int32_t Rewind();
int32_t Read(uint8_t * buffer, int32_t buffer_size, int32_t pos);
int32_t Read(uint8_t *buffer, int32_t buffer_size, int32_t pos);
protected:
void OpenFile();
struct mad_stream Stream;
struct mad_frame Frame;
struct mad_synth Synth;
mad_timer_t Timer;
uint8_t * GuardPtr;
uint8_t * ReadBuffer;
uint8_t *GuardPtr;
uint8_t *ReadBuffer;
uint32_t SynthPos;
};

12
include/gui/sounds/OggDecoder.hpp
View File

@ -30,13 +30,19 @@
class OggDecoder : public SoundDecoder {
public:
OggDecoder(const char * filepath);
OggDecoder(const uint8_t * snd, int32_t len);
OggDecoder(const char *filepath);
OggDecoder(const uint8_t *snd, int32_t len);
virtual ~OggDecoder();
int32_t Rewind();
int32_t Read(uint8_t * buffer, int32_t buffer_size, int32_t pos);
int32_t Read(uint8_t *buffer, int32_t buffer_size, int32_t pos);
protected:
void OpenFile();
OggVorbis_File ogg_file;
vorbis_info *ogg_info;
};

33
include/gui/sounds/SoundDecoder.hpp
View File

@ -35,61 +35,83 @@ class CFile;
class SoundDecoder {
public:
SoundDecoder();
SoundDecoder(const std::string & filepath);
SoundDecoder(const uint8_t * buffer, int32_t size);
SoundDecoder(const std::string &filepath);
SoundDecoder(const uint8_t *buffer, int32_t size);
virtual ~SoundDecoder();
virtual void Lock() {
mutex.lock();
}
virtual void Unlock() {
mutex.unlock();
}
virtual int32_t Read(uint8_t * buffer, int32_t buffer_size, int32_t pos);
virtual int32_t Read(uint8_t *buffer, int32_t buffer_size, int32_t pos);
virtual int32_t Tell() {
return CurPos;
}
virtual int32_t Seek(int32_t pos);
virtual int32_t Rewind();
virtual uint16_t GetFormat() {
return Format;
}
virtual uint16_t GetSampleRate() {
return SampleRate;
}
virtual void Decode();
virtual bool IsBufferReady() {
return SoundBuffer.IsBufferReady();
}
virtual uint8_t * GetBuffer() {
virtual uint8_t *GetBuffer() {
return SoundBuffer.GetBuffer();
}
virtual uint32_t GetBufferSize() {
return SoundBuffer.GetBufferSize();
}
virtual void LoadNext() {
SoundBuffer.LoadNext();
}
virtual bool IsEOF() {
return EndOfFile;
}
virtual void SetLoop(bool l) {
Loop = l;
EndOfFile = false;
}
virtual uint8_t GetSoundType() {
return SoundType;
}
virtual void ClearBuffer() {
SoundBuffer.ClearBuffer();
whichLoad = 0;
}
virtual bool IsStereo() {
return (GetFormat() & CHANNELS_STEREO) != 0;
}
virtual bool Is16Bit() {
return ((GetFormat() & 0xFF) == FORMAT_PCM_16_BIT);
}
virtual bool IsDecoding() {
return Decoding;
}
@ -113,9 +135,10 @@ public:
};
protected:
void Init();
void Upsample(int16_t *src, int16_t *dst, uint32_t nr_src_samples, uint32_t nr_dst_samples);
CFile * file_fd;
CFile *file_fd;
BufferCircle SoundBuffer;
uint8_t SoundType;
uint16_t whichLoad;

29
include/gui/sounds/SoundHandler.hpp
View File

@ -33,11 +33,11 @@
#include <gui/sounds/Voice.h>
#include <sndcore2/voice.h>
#define MAX_DECODERS 16 // can be increased up to 96
#define MAX_DECODERS 16 // can be increased up to 96
class SoundHandler : public CThread {
public:
static SoundHandler * instance() {
static SoundHandler *instance() {
if (!handlerInstance)
handlerInstance = new SoundHandler();
return handlerInstance;
@ -48,42 +48,49 @@ public:
handlerInstance = NULL;
}
void AddDecoder(int32_t voice, const char * filepath);
void AddDecoder(int32_t voice, const uint8_t * snd, int32_t len);
void AddDecoder(int32_t voice, const char *filepath);
void AddDecoder(int32_t voice, const uint8_t *snd, int32_t len);
void RemoveDecoder(int32_t voice);
SoundDecoder * getDecoder(int32_t i) {
SoundDecoder *getDecoder(int32_t i) {
return ((i < 0 || i >= MAX_DECODERS) ? NULL : DecoderList[i]);
};
Voice * getVoice(int32_t i) {
Voice *getVoice(int32_t i) {
return ((i < 0 || i >= MAX_DECODERS) ? NULL : voiceList[i]);
};
void ThreadSignal() {
resumeThread();
};
bool IsDecoding() {
return Decoding;
};
protected:
SoundHandler();
~SoundHandler();
static void axFrameCallback(void);
void executeThread(void);
void ClearDecoderList();
SoundDecoder * GetSoundDecoder(const char * filepath);
SoundDecoder * GetSoundDecoder(const uint8_t * sound, int32_t length);
SoundDecoder *GetSoundDecoder(const char *filepath);
static SoundHandler * handlerInstance;
SoundDecoder *GetSoundDecoder(const uint8_t *sound, int32_t length);
static SoundHandler *handlerInstance;
bool Decoding;
bool ExitRequested;
Voice * voiceList[MAX_DECODERS];
SoundDecoder * DecoderList[MAX_DECODERS];
Voice *voiceList[MAX_DECODERS];
SoundDecoder *DecoderList[MAX_DECODERS];
};
#endif

28
include/gui/sounds/Voice.h
View File

@ -36,12 +36,12 @@ public:
};
Voice(int32_t prio)
: state(STATE_STOPPED) {
: state(STATE_STOPPED) {
lastLoopCounter = 0;
nextBufferSize = 0;
voice = AXAcquireVoice(prio, 0, 0);
if(voice) {
if (voice) {
AXVoiceBegin(voice);
AXSetVoiceType(voice, 0);
setVolume(0x80000000);
@ -62,13 +62,13 @@ public:
}
~Voice() {
if(voice) {
if (voice) {
AXFreeVoice(voice);
}
}
void play(const uint8_t *buffer, uint32_t bufferSize, const uint8_t *nextBuffer, uint32_t nextBufSize, uint16_t format, uint32_t sampleRate) {
if(!voice)
if (!voice)
return;
memset(&voiceBuffer, 0, sizeof(voiceBuffer));
@ -86,7 +86,7 @@ public:
uint32_t samplesPerSec = AXGetInputSamplesPerSec();
memset(&ratioBits, 0, sizeof(ratioBits));
ratioBits.ratio = (uint32_t)(0x00010000 * ((float)sampleRate / (float)samplesPerSec));
ratioBits.ratio = (uint32_t) (0x00010000 * ((float) sampleRate / (float) samplesPerSec));
AXSetVoiceOffsets(voice, &voiceBuffer);
AXSetVoiceSrc(voice, &ratioBits);
@ -95,12 +95,12 @@ public:
}
void stop() {
if(voice)
if (voice)
AXSetVoiceState(voice, 0);
}
void setVolume(uint32_t vol) {
if(voice) {
if (voice) {
AXVoiceVeData data;
data.volume = vol >> 16;
data.delta = vol & 0xFFFF;
@ -110,7 +110,7 @@ public:
void setNextBuffer(const uint8_t *buffer, uint32_t bufferSize) {
voiceBuffer.loopOffset = ((buffer - (const uint8_t*)voiceBuffer.data) >> 1);
voiceBuffer.loopOffset = ((buffer - (const uint8_t *) voiceBuffer.data) >> 1);
nextBufferSize = bufferSize;
AXSetVoiceLoopOffset(voice, voiceBuffer.loopOffset);
@ -118,27 +118,29 @@ public:
bool isBufferSwitched() {
uint32_t loopCounter = AXGetVoiceLoopCount(voice);
if(lastLoopCounter != loopCounter) {
if (lastLoopCounter != loopCounter) {
lastLoopCounter = loopCounter;
AXSetVoiceEndOffset(voice, voiceBuffer.loopOffset + (nextBufferSize >> 1) - 1);
AXSetVoiceEndOffset(voice, voiceBuffer.loopOffset + (nextBufferSize >> 1) - 1);
return true;
}
return false;
}
uint32_t getInternState() const {
if(voice)
return ((uint32_t *)voice)[1];
if (voice)
return ((uint32_t *) voice)[1];
return 0;
}
uint32_t getState() const {
return state;
}
void setState(uint32_t s) {
state = s;
}
void * getVoice() const {
void *getVoice() const {
return voice;
}

12
include/gui/sounds/WavDecoder.hpp
View File

@ -52,13 +52,19 @@ typedef struct {
class WavDecoder : public SoundDecoder {
public:
WavDecoder(const char * filepath);
WavDecoder(const uint8_t * snd, int32_t len);
WavDecoder(const char *filepath);
WavDecoder(const uint8_t *snd, int32_t len);
virtual ~WavDecoder();
int32_t Read(uint8_t * buffer, int32_t buffer_size, int32_t pos);
int32_t Read(uint8_t *buffer, int32_t buffer_size, int32_t pos);
protected:
void OpenFile();
void CloseFile();
uint32_t DataOffset;
uint32_t DataSize;
bool Is16Bit;

51
include/gui/system/CThread.h
View File

@ -23,23 +23,20 @@
class CThread {
public:
typedef void (* Callback)(CThread *thread, void *arg);
typedef void (*Callback)(CThread *thread, void *arg);
//! constructor
CThread(int32_t iAttr, int32_t iPriority = 16, int32_t iStackSize = 0x8000, CThread::Callback callback = NULL, void *callbackArg = NULL)
: pThread(NULL)
, pThreadStack(NULL)
, pCallback(callback)
, pCallbackArg(callbackArg) {
: pThread(NULL), pThreadStack(NULL), pCallback(callback), pCallbackArg(callbackArg) {
//! save attribute assignment
iAttributes = iAttr;
//! allocate the thread
pThread = (OSThread*)memalign(8, sizeof(OSThread));
pThread = (OSThread *) memalign(8, sizeof(OSThread));
//! allocate the stack
pThreadStack = (uint8_t *) memalign(0x20, iStackSize);
//! create the thread
if(pThread && pThreadStack)
OSCreateThread(pThread, &CThread::threadCallback, 1, (char*)this, pThreadStack+iStackSize, iStackSize, iPriority, iAttributes);
if (pThread && pThreadStack)
OSCreateThread(pThread, &CThread::threadCallback, 1, (char *) this, pThreadStack + iStackSize, iStackSize, iPriority, iAttributes);
}
//! destructor
@ -48,71 +45,80 @@ public:
}
static CThread *create(CThread::Callback callback, void *callbackArg, int32_t iAttr = eAttributeNone, int32_t iPriority = 16, int32_t iStackSize = 0x8000) {
return ( new CThread(iAttr, iPriority, iStackSize, callback, callbackArg) );
return (new CThread(iAttr, iPriority, iStackSize, callback, callbackArg));
}
//! Get thread ID
virtual void* getThread() const {
virtual void *getThread() const {
return pThread;
}
//! Thread entry function
virtual void executeThread(void) {
if(pCallback)
if (pCallback)
pCallback(this, pCallbackArg);
}
//! Suspend thread
virtual void suspendThread(void) {
if(isThreadSuspended())
if (isThreadSuspended())
return;
if(pThread)
if (pThread)
OSSuspendThread(pThread);
}
//! Resume thread
virtual void resumeThread(void) {
if(!isThreadSuspended())
if (!isThreadSuspended())
return;
if(pThread)
if (pThread)
OSResumeThread(pThread);
}
//! Set thread priority
virtual void setThreadPriority(int32_t prio) {
if(pThread)
if (pThread)
OSSetThreadPriority(pThread, prio);
}
//! Check if thread is suspended
virtual bool isThreadSuspended(void) const {
if(pThread)
if (pThread)
return OSIsThreadSuspended(pThread);
return false;
}
//! Check if thread is terminated
virtual bool isThreadTerminated(void) const {
if(pThread)
if (pThread)
return OSIsThreadTerminated(pThread);
return false;
}
//! Check if thread is running
virtual bool isThreadRunning(void) const {
return !isThreadSuspended() && !isThreadRunning();
}
//! Shutdown thread
virtual void shutdownThread(void) {
//! wait for thread to finish
if(pThread && !(iAttributes & eAttributeDetach)) {
if(isThreadSuspended())
if (pThread && !(iAttributes & eAttributeDetach)) {
if (isThreadSuspended())
resumeThread();
OSJoinThread(pThread, NULL);
}
//! free the thread stack buffer
if(pThreadStack)
if (pThreadStack)
free(pThreadStack);
if(pThread)
if (pThread)
free(pThread);
pThread = NULL;
pThreadStack = NULL;
}
//! Thread attributes
enum eCThreadAttributes {
eAttributeNone = 0x07,
@ -128,6 +134,7 @@ private:
((CThread *) argv)->executeThread();
return 0;
}
int32_t iAttributes;
OSThread *pThread;
uint8_t *pThreadStack;

25
include/gui/video/CVideo.h
View File

@ -33,6 +33,7 @@
class CVideo {
public:
CVideo(int32_t forceTvScanMode = -1, int32_t forceDrcScanMode = -1);
virtual ~CVideo();
void prepareTvRendering(void) {
@ -64,7 +65,7 @@ public:
}
void setStencilRender(bool bEnable) {
if(bEnable) {
if (bEnable) {
GX2SetStencilMask(0xff, 0xff, 0x01, 0xff, 0xff, 0x01);
GX2SetDepthStencilControl(GX2_DISABLE, GX2_DISABLE, GX2_COMPARE_FUNC_LEQUAL, GX2_ENABLE, GX2_ENABLE, GX2_COMPARE_FUNC_ALWAYS, GX2_STENCIL_FUNCTION_KEEP, GX2_STENCIL_FUNCTION_KEEP, GX2_STENCIL_FUNCTION_REPLACE,
GX2_COMPARE_FUNC_ALWAYS, GX2_STENCIL_FUNCTION_KEEP, GX2_STENCIL_FUNCTION_KEEP, GX2_STENCIL_FUNCTION_REPLACE);
@ -94,13 +95,14 @@ public:
}
void tvEnable(bool bEnable) {
if(tvEnabled != bEnable) {
if (tvEnabled != bEnable) {
GX2SetTVEnable(bEnable ? GX2_ENABLE : GX2_DISABLE);
tvEnabled = bEnable;
}
}
void drcEnable(bool bEnable) {
if(drcEnabled != bEnable) {
if (drcEnabled != bEnable) {
GX2SetDRCEnable(bEnable ? GX2_ENABLE : GX2_DISABLE);
drcEnabled = bEnable;
}
@ -113,6 +115,7 @@ public:
uint32_t getTvWidth(void) const {
return tvColorBuffer.surface.width;
}
uint32_t getTvHeight(void) const {
return tvColorBuffer.surface.height;
}
@ -120,28 +123,32 @@ public:
uint32_t getDrcWidth(void) const {
return drcColorBuffer.surface.width;
}
uint32_t getDrcHeight(void) const {
return drcColorBuffer.surface.height;
}
const glm::mat4 & getProjectionMtx(void) const {
const glm::mat4 &getProjectionMtx(void) const {
return projectionMtx;
}
const glm::mat4 & getViewMtx(void) const {
const glm::mat4 &getViewMtx(void) const {
return viewMtx;
}
float getWidthScaleFactor(void) const {
return widthScaleFactor;
}
float getHeightScaleFactor(void) const {
return heightScaleFactor;
}
float getDepthScaleFactor(void) const {
return depthScaleFactor;
}
void screenPosToWorldRay(float posX, float posY, glm::vec3 & rayOrigin, glm::vec3 & rayDirection) {
void screenPosToWorldRay(float posX, float posY, glm::vec3 &rayOrigin, glm::vec3 &rayDirection) {
//! normalize positions
posX = 2.0f * posX * getWidthScaleFactor();
posY = 2.0f * posY * getHeightScaleFactor();
@ -162,11 +169,13 @@ public:
rayOrigin = glm::vec3(rayStartWorld);
rayDirection = glm::normalize(rayDirectionWorld);
}
private:
static void *GX2RAlloc(uint32_t flags, uint32_t size, uint32_t align);
static void GX2RFree(uint32_t flags, void* p);
void renderFXAA(const GX2Texture * texture, const GX2Sampler *sampler);
static void GX2RFree(uint32_t flags, void *p);
void renderFXAA(const GX2Texture *texture, const GX2Sampler *sampler);
void *gx2CommandBuffer;

16
include/gui/video/CursorDrawer.h
View File

@ -26,34 +26,38 @@ class CursorDrawer {
public:
static CursorDrawer *getInstance() {
if(!instance)
if (!instance)
instance = new CursorDrawer();
return instance;
}
static void destroyInstance() {
if(instance) {
if (instance) {
delete instance;
instance = NULL;
}
}
static void draw(float x, float y) {
CursorDrawer * cur_instance = getInstance();
if(cur_instance == NULL) return;
cur_instance->draw_Cursor(x,y);
CursorDrawer *cur_instance = getInstance();
if (cur_instance == NULL) return;
cur_instance->draw_Cursor(x, y);
}
private:
//!Constructor
CursorDrawer();
//!Destructor
~CursorDrawer();
static CursorDrawer *instance;
void draw_Cursor(float x, float y);
void init_colorVtxs();
uint8_t * colorVtxs = NULL;
uint8_t *colorVtxs = NULL;
};
#endif

21
include/gui/video/shaders/ColorShader.h
View File

@ -24,6 +24,7 @@
class ColorShader : public Shader {
private:
ColorShader();
virtual ~ColorShader();
static const uint32_t cuAttributeCount = 2;
@ -47,13 +48,14 @@ public:
static const uint32_t cuColorVtxsSize = 4 * cuColorAttrSize;
static ColorShader *instance() {
if(!shaderInstance) {
if (!shaderInstance) {
shaderInstance = new ColorShader();
}
return shaderInstance;
}
static void destroyInstance() {
if(shaderInstance) {
if (shaderInstance) {
delete shaderInstance;
shaderInstance = NULL;
}
@ -65,8 +67,8 @@ public:
pixelShader.setShader();
}
void setAttributeBuffer(const uint8_t * colorAttr, const float * posVtxs_in = NULL, const uint32_t & vtxCount = 0) const {
if(posVtxs_in && vtxCount) {
void setAttributeBuffer(const uint8_t *colorAttr, const float *posVtxs_in = NULL, const uint32_t &vtxCount = 0) const {
if (posVtxs_in && vtxCount) {
VertexShader::setAttributeBuffer(0, vtxCount * cuVertexAttrSize, cuVertexAttrSize, posVtxs_in);
VertexShader::setAttributeBuffer(1, vtxCount * cuColorAttrSize, cuColorAttrSize, colorAttr);
} else {
@ -75,16 +77,19 @@ public:
}
}
void setAngle(const float & val) {
void setAngle(const float &val) {
VertexShader::setUniformReg(angleLocation, 4, &val);
}
void setOffset(const glm::vec3 & vec) {
void setOffset(const glm::vec3 &vec) {
VertexShader::setUniformReg(offsetLocation, 4, &vec[0]);
}
void setScale(const glm::vec3 & vec) {
void setScale(const glm::vec3 &vec) {
VertexShader::setUniformReg(scaleLocation, 4, &vec[0]);
}
void setColorIntensity(const glm::vec4 & vec) {
void setColorIntensity(const glm::vec4 &vec) {
PixelShader::setUniformReg(colorIntensityLocation, 4, &vec[0]);
}
};

12
include/gui/video/shaders/FXAAShader.h
View File

@ -24,13 +24,14 @@
class FXAAShader : public Shader {
public:
static FXAAShader *instance() {
if(!shaderInstance) {
if (!shaderInstance) {
shaderInstance = new FXAAShader();
}
return shaderInstance;
}
static void destroyInstance() {
if(shaderInstance) {
if (shaderInstance) {
delete shaderInstance;
shaderInstance = NULL;
}
@ -47,17 +48,18 @@ public:
VertexShader::setAttributeBuffer(1, ciTexCoordsVtxsSize, cuTexCoordAttrSize, texCoords);
}
void setResolution(const glm::vec2 & vec) {
void setResolution(const glm::vec2 &vec) {
PixelShader::setUniformReg(resolutionLocation, 4, &vec[0]);
}
void setTextureAndSampler(const GX2Texture *texture, const GX2Sampler *sampler) const {
GX2SetPixelTexture((GX2Texture*)texture, samplerLocation);
GX2SetPixelSampler((GX2Sampler*)sampler, samplerLocation);
GX2SetPixelTexture((GX2Texture *) texture, samplerLocation);
GX2SetPixelSampler((GX2Sampler *) sampler, samplerLocation);
}
private:
FXAAShader();
virtual ~FXAAShader();
static const uint32_t cuAttributeCount = 2;

14
include/gui/video/shaders/FetchShader.h
View File

@ -21,21 +21,21 @@
class FetchShader : public Shader {
public:
FetchShader(GX2AttribStream * attributes, uint32_t attrCount, GX2FetchShaderType type = GX2_FETCH_SHADER_TESSELLATION_NONE, GX2TessellationMode tess = GX2_TESSELLATION_MODE_DISCRETE)
: fetchShader(NULL)
, fetchShaderProgramm(NULL) {
FetchShader(GX2AttribStream *attributes, uint32_t attrCount, GX2FetchShaderType type = GX2_FETCH_SHADER_TESSELLATION_NONE, GX2TessellationMode tess = GX2_TESSELLATION_MODE_DISCRETE)
: fetchShader(NULL), fetchShaderProgramm(NULL) {
uint32_t shaderSize = GX2CalcFetchShaderSizeEx(attrCount, type, tess);
fetchShaderProgramm = (uint8_t*)memalign(GX2_SHADER_PROGRAM_ALIGNMENT, shaderSize);
if(fetchShaderProgramm) {
fetchShaderProgramm = (uint8_t *) memalign(GX2_SHADER_PROGRAM_ALIGNMENT, shaderSize);
if (fetchShaderProgramm) {
fetchShader = new GX2FetchShader;
GX2InitFetchShaderEx(fetchShader, fetchShaderProgramm, attrCount, attributes, type, tess);
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_SHADER, fetchShaderProgramm, shaderSize);
}
}
virtual ~FetchShader() {
if(fetchShaderProgramm)
if (fetchShaderProgramm)
free(fetchShaderProgramm);
if(fetchShader)
if (fetchShader)
delete fetchShader;
}

85
include/gui/video/shaders/PixelShader.h
View File

@ -22,53 +22,54 @@
class PixelShader : public Shader {
public:
PixelShader()
: pixelShader((GX2PixelShader*) memalign(0x40, sizeof(GX2PixelShader))) {
if(pixelShader) {
: pixelShader((GX2PixelShader *) memalign(0x40, sizeof(GX2PixelShader))) {
if (pixelShader) {
memset(pixelShader, 0, sizeof(GX2PixelShader));
pixelShader->mode = GX2_SHADER_MODE_UNIFORM_REGISTER;
}
}
virtual ~PixelShader() {
if(pixelShader) {
if(pixelShader->program)
if (pixelShader) {
if (pixelShader->program)
free(pixelShader->program);
for(uint32_t i = 0; i < pixelShader->uniformBlockCount; i++)
free((void*)pixelShader->uniformBlocks[i].name);
for (uint32_t i = 0; i < pixelShader->uniformBlockCount; i++)
free((void *) pixelShader->uniformBlocks[i].name);
if(pixelShader->uniformBlocks)
free((void*)pixelShader->uniformBlocks);
if (pixelShader->uniformBlocks)
free((void *) pixelShader->uniformBlocks);
for(uint32_t i = 0; i < pixelShader->uniformVarCount; i++)
free((void*)pixelShader->uniformVars[i].name);
for (uint32_t i = 0; i < pixelShader->uniformVarCount; i++)
free((void *) pixelShader->uniformVars[i].name);
if(pixelShader->uniformVars)
free((void*)pixelShader->uniformVars);
if (pixelShader->uniformVars)
free((void *) pixelShader->uniformVars);
if(pixelShader->initialValues)
free((void*)pixelShader->initialValues);
if (pixelShader->initialValues)
free((void *) pixelShader->initialValues);
for(uint32_t i = 0; i < pixelShader->samplerVarCount; i++)
free((void*)pixelShader->samplerVars[i].name);
for (uint32_t i = 0; i < pixelShader->samplerVarCount; i++)
free((void *) pixelShader->samplerVars[i].name);
if(pixelShader->samplerVars)
free((void*)pixelShader->samplerVars);
if (pixelShader->samplerVars)
free((void *) pixelShader->samplerVars);
if(pixelShader->loopVars)
free((void*)pixelShader->loopVars);
if (pixelShader->loopVars)
free((void *) pixelShader->loopVars);
free(pixelShader);
}
}
void setProgram(const uint32_t * program, const uint32_t & programSize, const uint32_t * regs, const uint32_t & regsSize) {
if(!pixelShader)
void setProgram(const uint32_t *program, const uint32_t &programSize, const uint32_t *regs, const uint32_t &regsSize) {
if (!pixelShader)
return;
//! this must be moved into an area where the graphic engine has access to and must be aligned to 0x100
pixelShader->size = programSize;
pixelShader->program = (uint8_t*)memalign(GX2_SHADER_PROGRAM_ALIGNMENT, pixelShader->size);
if(pixelShader->program) {
pixelShader->program = (uint8_t *) memalign(GX2_SHADER_PROGRAM_ALIGNMENT, pixelShader->size);
if (pixelShader->program) {
memcpy(pixelShader->program, program, pixelShader->size);
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_SHADER, pixelShader->program, pixelShader->size);
}
@ -76,50 +77,51 @@ public:
memcpy(&pixelShader->regs, regs, regsSize);
}
void addUniformVar(const GX2UniformVar & var) {
if(!pixelShader)
void addUniformVar(const GX2UniformVar &var) {
if (!pixelShader)
return;
uint32_t idx = pixelShader->uniformVarCount;
GX2UniformVar* newVar = (GX2UniformVar*) malloc((pixelShader->uniformVarCount + 1) * sizeof(GX2UniformVar));
if(newVar) {
if(pixelShader->uniformVars) {
GX2UniformVar *newVar = (GX2UniformVar *) malloc((pixelShader->uniformVarCount + 1) * sizeof(GX2UniformVar));
if (newVar) {
if (pixelShader->uniformVars) {
memcpy(newVar, pixelShader->uniformVars, pixelShader->uniformVarCount * sizeof(GX2UniformVar));
free(pixelShader->uniformVars);
}
pixelShader->uniformVars = newVar;
memcpy(pixelShader->uniformVars + idx, &var, sizeof(GX2UniformVar));
pixelShader->uniformVars[idx].name = (char*) malloc(strlen(var.name) + 1);
strcpy((char*)pixelShader->uniformVars[idx].name, var.name);
pixelShader->uniformVars[idx].name = (char *) malloc(strlen(var.name) + 1);
strcpy((char *) pixelShader->uniformVars[idx].name, var.name);
pixelShader->uniformVarCount++;
}
}
void addSamplerVar(const GX2SamplerVar & var) {
if(!pixelShader)
void addSamplerVar(const GX2SamplerVar &var) {
if (!pixelShader)
return;
uint32_t idx = pixelShader->samplerVarCount;
GX2SamplerVar* newVar = (GX2SamplerVar*) malloc((pixelShader->samplerVarCount + 1) * sizeof(GX2SamplerVar));
if(newVar) {
if(pixelShader->samplerVars) {
GX2SamplerVar *newVar = (GX2SamplerVar *) malloc((pixelShader->samplerVarCount + 1) * sizeof(GX2SamplerVar));
if (newVar) {
if (pixelShader->samplerVars) {
memcpy(newVar, pixelShader->samplerVars, pixelShader->samplerVarCount * sizeof(GX2SamplerVar));
free(pixelShader->samplerVars);
}
pixelShader->samplerVars = newVar;
memcpy(pixelShader->samplerVars + idx, &var, sizeof(GX2SamplerVar));
pixelShader->samplerVars[idx].name = (char*) malloc(strlen(var.name) + 1);
strcpy((char*)pixelShader->samplerVars[idx].name, var.name);
pixelShader->samplerVars[idx].name = (char *) malloc(strlen(var.name) + 1);
strcpy((char *) pixelShader->samplerVars[idx].name, var.name);
pixelShader->samplerVarCount++;
}
}
GX2PixelShader * getPixelShader() const {
GX2PixelShader *getPixelShader() const {
return pixelShader;
}
@ -127,9 +129,10 @@ public:
GX2SetPixelShader(pixelShader);
}
static inline void setUniformReg(uint32_t location, uint32_t size, const void * reg) {
GX2SetPixelUniformReg(location, size, (uint32_t *)reg);
static inline void setUniformReg(uint32_t location, uint32_t size, const void *reg) {
GX2SetPixelUniformReg(location, size, (uint32_t *) reg);
}
protected:
GX2PixelShader *pixelShader;
};

50
include/gui/video/shaders/Shader.h
View File

@ -29,40 +29,42 @@
class Shader {
protected:
Shader() {}
virtual ~Shader() {}
public:
static const uint16_t cuVertexAttrSize = sizeof(float) * 3;
static const uint16_t cuTexCoordAttrSize = sizeof(float) * 2;
static const uint16_t cuColorAttrSize = sizeof(uint8_t) * 4;
static void setLineWidth(const float & width) {
static void setLineWidth(const float &width) {
GX2SetLineWidth(width);
}
static void draw(int32_t primitive = GX2_PRIMITIVE_MODE_QUADS, uint32_t vtxCount = 4) {
switch(primitive) {
default:
case GX2_PRIMITIVE_MODE_QUADS: {
GX2DrawEx(GX2_PRIMITIVE_MODE_QUADS, vtxCount, 0, 1);
break;
}
case GX2_PRIMITIVE_MODE_TRIANGLES: {
GX2DrawEx(GX2_PRIMITIVE_MODE_TRIANGLES, vtxCount, 0, 1);
break;
}
case GX2_PRIMITIVE_MODE_TRIANGLE_FAN: {
GX2DrawEx(GX2_PRIMITIVE_MODE_TRIANGLE_FAN, vtxCount, 0, 1);
break;
}
case GX2_PRIMITIVE_MODE_LINES: {
GX2DrawEx(GX2_PRIMITIVE_MODE_LINES, vtxCount, 0, 1);
break;
}
case GX2_PRIMITIVE_MODE_LINE_STRIP: {
GX2DrawEx(GX2_PRIMITIVE_MODE_LINE_STRIP, vtxCount, 0, 1);
break;
}
//! TODO: add other primitives later
switch (primitive) {
default:
case GX2_PRIMITIVE_MODE_QUADS: {
GX2DrawEx(GX2_PRIMITIVE_MODE_QUADS, vtxCount, 0, 1);
break;
}
case GX2_PRIMITIVE_MODE_TRIANGLES: {
GX2DrawEx(GX2_PRIMITIVE_MODE_TRIANGLES, vtxCount, 0, 1);
break;
}
case GX2_PRIMITIVE_MODE_TRIANGLE_FAN: {
GX2DrawEx(GX2_PRIMITIVE_MODE_TRIANGLE_FAN, vtxCount, 0, 1);
break;
}
case GX2_PRIMITIVE_MODE_LINES: {
GX2DrawEx(GX2_PRIMITIVE_MODE_LINES, vtxCount, 0, 1);
break;
}
case GX2_PRIMITIVE_MODE_LINE_STRIP: {
GX2DrawEx(GX2_PRIMITIVE_MODE_LINE_STRIP, vtxCount, 0, 1);
break;
}
//! TODO: add other primitives later
};
}
};

33
include/gui/video/shaders/Shader3D.h
View File

@ -24,9 +24,10 @@
class Shader3D : public Shader {
private:
Shader3D();
virtual ~Shader3D();
static Shader3D * shaderInstance;
static Shader3D *shaderInstance;
static const unsigned char cuAttributeCount = 2;
static const uint32_t ciPositionVtxsSize = 4 * cuVertexAttrSize;
@ -51,13 +52,14 @@ private:
uint32_t samplerLocation;
public:
static Shader3D *instance() {
if(!shaderInstance) {
if (!shaderInstance) {
shaderInstance = new Shader3D();
}
return shaderInstance;
}
static void destroyInstance() {
if(shaderInstance) {
if (shaderInstance) {
delete shaderInstance;
shaderInstance = NULL;
}
@ -69,8 +71,8 @@ public:
pixelShader.setShader();
}
void setAttributeBuffer(const uint32_t & vtxCount = 0, const float * posVtxs_in = NULL, const float * texCoords_in = NULL) const {
if(posVtxs_in && texCoords_in && vtxCount) {
void setAttributeBuffer(const uint32_t &vtxCount = 0, const float *posVtxs_in = NULL, const float *texCoords_in = NULL) const {
if (posVtxs_in && texCoords_in && vtxCount) {
VertexShader::setAttributeBuffer(0, vtxCount * cuVertexAttrSize, cuVertexAttrSize, posVtxs_in);
VertexShader::setAttributeBuffer(1, vtxCount * cuTexCoordAttrSize, cuTexCoordAttrSize, texCoords_in);
} else {
@ -80,28 +82,33 @@ public:
}
}
void setProjectionMtx(const glm::mat4 & mtx) {
void setProjectionMtx(const glm::mat4 &mtx) {
VertexShader::setUniformReg(projectionMatrixLocation, 16, &mtx[0][0]);
}
void setViewMtx(const glm::mat4 & mtx) {
void setViewMtx(const glm::mat4 &mtx) {
VertexShader::setUniformReg(viewMatrixLocation, 16, &mtx[0][0]);
}
void setModelViewMtx(const glm::mat4 & mtx) {
void setModelViewMtx(const glm::mat4 &mtx) {
VertexShader::setUniformReg(modelMatrixLocation, 16, &mtx[0][0]);
}
void setColorIntensity(const glm::vec4 & vec) {
void setColorIntensity(const glm::vec4 &vec) {
PixelShader::setUniformReg(colorIntensityLocation, 4, &vec[0]);
}
void setAlphaFadeOut(const glm::vec4 & vec) {
void setAlphaFadeOut(const glm::vec4 &vec) {
PixelShader::setUniformReg(fadeOutLocation, 4, &vec[0]);
}
void setDistanceFadeOut(const float & value) {
void setDistanceFadeOut(const float &value) {
PixelShader::setUniformReg(fadeDistanceLocation, 4, &value);
}
void setTextureAndSampler(const GX2Texture *texture, const GX2Sampler *sampler) const {
GX2SetPixelTexture((GX2Texture*)texture, samplerLocation);
GX2SetPixelSampler((GX2Sampler*)sampler, samplerLocation);
GX2SetPixelTexture((GX2Texture *) texture, samplerLocation);
GX2SetPixelSampler((GX2Sampler *) sampler, samplerLocation);
}
};

32
include/gui/video/shaders/ShaderFractalColor.h
View File

@ -20,12 +20,14 @@
#include <gui/video/shaders/VertexShader.h>
#include <gui/video/shaders/PixelShader.h>
#include <gui/video/shaders/FetchShader.h>
class ShaderFractalColor : public Shader {
private:
ShaderFractalColor();
virtual ~ShaderFractalColor();
static ShaderFractalColor * shaderInstance;
static ShaderFractalColor *shaderInstance;
static const unsigned char cuAttributeCount = 3;
static const uint32_t ciPositionVtxsSize = 4 * cuVertexAttrSize;
@ -53,13 +55,14 @@ private:
uint32_t fractalLocation;
public:
static ShaderFractalColor *instance() {
if(!shaderInstance) {
if (!shaderInstance) {
shaderInstance = new ShaderFractalColor();
}
return shaderInstance;
}
static void destroyInstance() {
if(shaderInstance) {
if (shaderInstance) {
delete shaderInstance;
shaderInstance = NULL;
}
@ -71,8 +74,8 @@ public:
pixelShader.setShader();
}
void setAttributeBuffer(const uint32_t & vtxCount = 0, const float * posVtxs_in = NULL, const float * texCoords_in = NULL, const uint8_t * colorVtxs_in = NULL) const {
if(posVtxs_in && texCoords_in && vtxCount) {
void setAttributeBuffer(const uint32_t &vtxCount = 0, const float *posVtxs_in = NULL, const float *texCoords_in = NULL, const uint8_t *colorVtxs_in = NULL) const {
if (posVtxs_in && texCoords_in && vtxCount) {
VertexShader::setAttributeBuffer(0, vtxCount * cuVertexAttrSize, cuVertexAttrSize, posVtxs_in);
VertexShader::setAttributeBuffer(1, vtxCount * cuTexCoordAttrSize, cuTexCoordAttrSize, texCoords_in);
VertexShader::setAttributeBuffer(2, vtxCount * cuColorAttrSize, cuColorAttrSize, colorVtxs_in);
@ -84,26 +87,31 @@ public:
}
}
void setProjectionMtx(const glm::mat4 & mtx) {
void setProjectionMtx(const glm::mat4 &mtx) {
VertexShader::setUniformReg(projectionMatrixLocation, 16, &mtx[0][0]);
}
void setViewMtx(const glm::mat4 & mtx) {
void setViewMtx(const glm::mat4 &mtx) {
VertexShader::setUniformReg(viewMatrixLocation, 16, &mtx[0][0]);
}
void setModelViewMtx(const glm::mat4 & mtx) {
void setModelViewMtx(const glm::mat4 &mtx) {
VertexShader::setUniformReg(modelMatrixLocation, 16, &mtx[0][0]);
}
void setBlurBorder(const float & blurBorderSize) {
void setBlurBorder(const float &blurBorderSize) {
PixelShader::setUniformReg(blurLocation, 4, &blurBorderSize);
}
void setColorIntensity(const glm::vec4 & vec) {
void setColorIntensity(const glm::vec4 &vec) {
PixelShader::setUniformReg(colorIntensityLocation, 4, &vec[0]);
}
void setAlphaFadeOut(const glm::vec4 & vec) {
void setAlphaFadeOut(const glm::vec4 &vec) {
PixelShader::setUniformReg(fadeOutLocation, 4, &vec[0]);
}
void setFractalColor(const int & fractalColorEnable) {
void setFractalColor(const int &fractalColorEnable) {
PixelShader::setUniformReg(fractalLocation, 4, &fractalColorEnable);
}
};

28
include/gui/video/shaders/Texture2DShader.h
View File

@ -25,6 +25,7 @@
class Texture2DShader : public Shader {
private:
Texture2DShader();
virtual ~Texture2DShader();
static const uint32_t cuAttributeCount = 2;
@ -50,13 +51,14 @@ private:
uint32_t texCoordLocation;
public:
static Texture2DShader *instance() {
if(!shaderInstance) {
if (!shaderInstance) {
shaderInstance = new Texture2DShader();
}
return shaderInstance;
}
static void destroyInstance() {
if(shaderInstance) {
if (shaderInstance) {
delete shaderInstance;
shaderInstance = NULL;
}
@ -68,8 +70,8 @@ public:
pixelShader.setShader();
}
void setAttributeBuffer(const float * texCoords_in = NULL, const float * posVtxs_in = NULL, const uint32_t & vtxCount = 0) const {
if(posVtxs_in && texCoords_in && vtxCount) {
void setAttributeBuffer(const float *texCoords_in = NULL, const float *posVtxs_in = NULL, const uint32_t &vtxCount = 0) const {
if (posVtxs_in && texCoords_in && vtxCount) {
VertexShader::setAttributeBuffer(0, vtxCount * cuVertexAttrSize, cuVertexAttrSize, posVtxs_in);
VertexShader::setAttributeBuffer(1, vtxCount * cuTexCoordAttrSize, cuTexCoordAttrSize, texCoords_in);
} else {
@ -78,25 +80,29 @@ public:
}
}
void setAngle(const float & val) {
void setAngle(const float &val) {
VertexShader::setUniformReg(angleLocation, 4, &val);
}
void setOffset(const glm::vec3 & vec) {
void setOffset(const glm::vec3 &vec) {
VertexShader::setUniformReg(offsetLocation, 4, &vec[0]);
}
void setScale(const glm::vec3 & vec) {
void setScale(const glm::vec3 &vec) {
VertexShader::setUniformReg(scaleLocation, 4, &vec[0]);
}
void setColorIntensity(const glm::vec4 & vec) {
void setColorIntensity(const glm::vec4 &vec) {
PixelShader::setUniformReg(colorIntensityLocation, 4, &vec[0]);
}
void setBlurring(const glm::vec3 & vec) {
void setBlurring(const glm::vec3 &vec) {
PixelShader::setUniformReg(blurLocation, 4, &vec[0]);
}
void setTextureAndSampler(const GX2Texture *texture, const GX2Sampler *sampler) const {
GX2SetPixelTexture((GX2Texture*)texture, samplerLocation);
GX2SetPixelSampler((GX2Sampler*)sampler, samplerLocation);
GX2SetPixelTexture((GX2Texture *) texture, samplerLocation);
GX2SetPixelSampler((GX2Sampler *) sampler, samplerLocation);
}
};

102
include/gui/video/shaders/VertexShader.h
View File

@ -24,64 +24,62 @@
class VertexShader : public Shader {
public:
VertexShader(uint32_t numAttr)
: attributesCount( numAttr )
, attributes( new GX2AttribStream[attributesCount] )
, vertexShader( (GX2VertexShader*) memalign(0x40, sizeof(GX2VertexShader)) ) {
if(vertexShader) {
: attributesCount(numAttr), attributes(new GX2AttribStream[attributesCount]), vertexShader((GX2VertexShader *) memalign(0x40, sizeof(GX2VertexShader))) {
if (vertexShader) {
memset(vertexShader, 0, sizeof(GX2VertexShader));
vertexShader->mode = GX2_SHADER_MODE_UNIFORM_REGISTER;
}
}
virtual ~VertexShader() {
delete [] attributes;
delete[] attributes;
if(vertexShader) {
if(vertexShader->program)
if (vertexShader) {
if (vertexShader->program)
free(vertexShader->program);
for(uint32_t i = 0; i < vertexShader->uniformBlockCount; i++)
free((void*)vertexShader->uniformBlocks[i].name);
for (uint32_t i = 0; i < vertexShader->uniformBlockCount; i++)
free((void *) vertexShader->uniformBlocks[i].name);
if(vertexShader->uniformBlocks)
free((void*)vertexShader->uniformBlocks);
if (vertexShader->uniformBlocks)
free((void *) vertexShader->uniformBlocks);
for(uint32_t i = 0; i < vertexShader->uniformVarCount; i++)
free((void*)vertexShader->uniformVars[i].name);
for (uint32_t i = 0; i < vertexShader->uniformVarCount; i++)
free((void *) vertexShader->uniformVars[i].name);
if(vertexShader->uniformVars)
free((void*)vertexShader->uniformVars);
if (vertexShader->uniformVars)
free((void *) vertexShader->uniformVars);
if(vertexShader->initialValues)
free((void*)vertexShader->initialValues);
if (vertexShader->initialValues)
free((void *) vertexShader->initialValues);
for(uint32_t i = 0; i < vertexShader->samplerVarCount; i++)
free((void*)vertexShader->samplerVars[i].name);
for (uint32_t i = 0; i < vertexShader->samplerVarCount; i++)
free((void *) vertexShader->samplerVars[i].name);
if(vertexShader->samplerVars)
free((void*)vertexShader->samplerVars);
if (vertexShader->samplerVars)
free((void *) vertexShader->samplerVars);
for(uint32_t i = 0; i < vertexShader->attribVarCount; i++)
free((void*)vertexShader->attribVars[i].name);
for (uint32_t i = 0; i < vertexShader->attribVarCount; i++)
free((void *) vertexShader->attribVars[i].name);
if(vertexShader->attribVars)
free((void*)vertexShader->attribVars);
if (vertexShader->attribVars)
free((void *) vertexShader->attribVars);
if(vertexShader->loopVars)
free((void*)vertexShader->loopVars);
if (vertexShader->loopVars)
free((void *) vertexShader->loopVars);
free(vertexShader);
}
}
void setProgram(const uint32_t * program, const uint32_t & programSize, const uint32_t * regs, const uint32_t & regsSize) {
if(!vertexShader)
void setProgram(const uint32_t *program, const uint32_t &programSize, const uint32_t *regs, const uint32_t &regsSize) {
if (!vertexShader)
return;
//! this must be moved into an area where the graphic engine has access to and must be aligned to 0x100
vertexShader->size = programSize;
vertexShader->program = (uint8_t*) memalign(GX2_SHADER_PROGRAM_ALIGNMENT, vertexShader->size);
if(vertexShader->program) {
vertexShader->program = (uint8_t *) memalign(GX2_SHADER_PROGRAM_ALIGNMENT, vertexShader->size);
if (vertexShader->program) {
memcpy(vertexShader->program, program, vertexShader->size);
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_SHADER, vertexShader->program, vertexShader->size);
}
@ -89,52 +87,52 @@ public:
memcpy(&vertexShader->regs, regs, regsSize);
}
void addUniformVar(const GX2UniformVar & var) {
if(!vertexShader)
void addUniformVar(const GX2UniformVar &var) {
if (!vertexShader)
return;
uint32_t idx = vertexShader->uniformVarCount;
GX2UniformVar* newVar = (GX2UniformVar*) malloc((vertexShader->uniformVarCount + 1) * sizeof(GX2UniformVar));
if(newVar) {
if(vertexShader->uniformVarCount > 0) {
GX2UniformVar *newVar = (GX2UniformVar *) malloc((vertexShader->uniformVarCount + 1) * sizeof(GX2UniformVar));
if (newVar) {
if (vertexShader->uniformVarCount > 0) {
memcpy(newVar, vertexShader->uniformVars, vertexShader->uniformVarCount * sizeof(GX2UniformVar));
free(vertexShader->uniformVars);
}
vertexShader->uniformVars = newVar;
memcpy(vertexShader->uniformVars + idx, &var, sizeof(GX2UniformVar));
vertexShader->uniformVars[idx].name = (char*) malloc(strlen(var.name) + 1);
strcpy((char*)vertexShader->uniformVars[idx].name, var.name);
vertexShader->uniformVars[idx].name = (char *) malloc(strlen(var.name) + 1);
strcpy((char *) vertexShader->uniformVars[idx].name, var.name);
vertexShader->uniformVarCount++;
}
}
void addAttribVar(const GX2AttribVar & var) {
if(!vertexShader)
void addAttribVar(const GX2AttribVar &var) {
if (!vertexShader)
return;
uint32_t idx = vertexShader->attribVarCount;
GX2AttribVar* newVar = (GX2AttribVar*) malloc((vertexShader->attribVarCount + 1) * sizeof(GX2AttribVar));
if(newVar) {
if(vertexShader->attribVarCount > 0) {
GX2AttribVar *newVar = (GX2AttribVar *) malloc((vertexShader->attribVarCount + 1) * sizeof(GX2AttribVar));
if (newVar) {
if (vertexShader->attribVarCount > 0) {
memcpy(newVar, vertexShader->attribVars, vertexShader->attribVarCount * sizeof(GX2AttribVar));
free(vertexShader->attribVars);
}
vertexShader->attribVars = newVar;
memcpy(vertexShader->attribVars + idx, &var, sizeof(GX2AttribVar));
vertexShader->attribVars[idx].name = (char*) malloc(strlen(var.name) + 1);
strcpy((char*)vertexShader->attribVars[idx].name, var.name);
vertexShader->attribVars[idx].name = (char *) malloc(strlen(var.name) + 1);
strcpy((char *) vertexShader->attribVars[idx].name, var.name);
vertexShader->attribVarCount++;
}
}
static inline void setAttributeBuffer(uint32_t bufferIdx, uint32_t bufferSize, uint32_t stride, const void * buffer) {
GX2SetAttribBuffer(bufferIdx, bufferSize, stride, (void*)buffer);
static inline void setAttributeBuffer(uint32_t bufferIdx, uint32_t bufferSize, uint32_t stride, const void *buffer) {
GX2SetAttribBuffer(bufferIdx, bufferSize, stride, (void *) buffer);
}
GX2VertexShader *getVertexShader() const {
@ -145,19 +143,21 @@ public:
GX2SetVertexShader(vertexShader);
}
GX2AttribStream * getAttributeBuffer(uint32_t idx = 0) const {
if(idx >= attributesCount) {
GX2AttribStream *getAttributeBuffer(uint32_t idx = 0) const {
if (idx >= attributesCount) {
return NULL;
}
return &attributes[idx];
}
uint32_t getAttributesCount() const {
return attributesCount;
}
static void setUniformReg(uint32_t location, uint32_t size, const void * reg) {
GX2SetVertexUniformReg(location, size, (uint32_t*)reg);
static void setUniformReg(uint32_t location, uint32_t size, const void *reg) {
GX2SetVertexUniformReg(location, size, (uint32_t *) reg);
}
protected:
uint32_t attributesCount;
GX2AttribStream *attributes;

86
source/fs/CFile.cpp
View File

@ -12,12 +12,12 @@ CFile::CFile() {
pos = 0;
}
CFile::CFile(const std::string & filepath, eOpenTypes mode) {
CFile::CFile(const std::string &filepath, eOpenTypes mode) {
iFd = -1;
this->open(filepath, mode);
}
CFile::CFile(const uint8_t * mem, int32_t size) {
CFile::CFile(const uint8_t *mem, int32_t size) {
iFd = -1;
this->open(mem, size);
}
@ -26,27 +26,27 @@ CFile::~CFile() {
this->close();
}
int32_t CFile::open(const std::string & filepath, eOpenTypes mode) {
int32_t CFile::open(const std::string &filepath, eOpenTypes mode) {
this->close();
int32_t openMode = 0;
// This depend on the devoptab implementation.
// see https://github.com/devkitPro/wut/blob/master/libraries/wutdevoptab/devoptab_fs_open.c#L21 fpr reference
switch(mode) {
default:
case ReadOnly: // file must exist
openMode = O_RDONLY;
break;
case WriteOnly: // file will be created / zerod
openMode = O_TRUNC | O_CREAT | O_WRONLY;
break;
case ReadWrite: // file must exist
openMode = O_RDWR;
break;
case Append: // append to file, file will be created if missing. write only
openMode = O_CREAT | O_APPEND | O_WRONLY;
break;
switch (mode) {
default:
case ReadOnly: // file must exist
openMode = O_RDONLY;
break;
case WriteOnly: // file will be created / zerod
openMode = O_TRUNC | O_CREAT | O_WRONLY;
break;
case ReadWrite: // file must exist
openMode = O_RDWR;
break;
case Append: // append to file, file will be created if missing. write only
openMode = O_CREAT | O_APPEND | O_WRONLY;
break;
}
//! Using fopen works only on the first launch as expected
@ -54,7 +54,7 @@ int32_t CFile::open(const std::string & filepath, eOpenTypes mode) {
//! the .data sections which is needed for a normal application to re-init
//! this will be added with launching as RPX
iFd = ::open(filepath.c_str(), openMode);
if(iFd < 0)
if (iFd < 0)
return iFd;
@ -64,7 +64,7 @@ int32_t CFile::open(const std::string & filepath, eOpenTypes mode) {
return 0;
}
int32_t CFile::open(const uint8_t * mem, int32_t size) {
int32_t CFile::open(const uint8_t *mem, int32_t size) {
this->close();
mem_file = mem;
@ -74,7 +74,7 @@ int32_t CFile::open(const uint8_t * mem, int32_t size) {
}
void CFile::close() {
if(iFd >= 0)
if (iFd >= 0)
::close(iFd);
iFd = -1;
@ -83,24 +83,24 @@ void CFile::close() {
pos = 0;
}
int32_t CFile::read(uint8_t * ptr, size_t size) {
if(iFd >= 0) {
int32_t ret = ::read(iFd, ptr,size);
if(ret > 0)
int32_t CFile::read(uint8_t *ptr, size_t size) {
if (iFd >= 0) {
int32_t ret = ::read(iFd, ptr, size);
if (ret > 0)
pos += ret;
return ret;
}
int32_t readsize = size;
if(readsize > (int64_t) (filesize-pos))
readsize = filesize-pos;
if (readsize > (int64_t) (filesize - pos))
readsize = filesize - pos;
if(readsize <= 0)
if (readsize <= 0)
return readsize;
if(mem_file != NULL) {
memcpy(ptr, mem_file+pos, readsize);
if (mem_file != NULL) {
memcpy(ptr, mem_file + pos, readsize);
pos += readsize;
return readsize;
}
@ -108,12 +108,12 @@ int32_t CFile::read(uint8_t * ptr, size_t size) {
return -1;
}
int32_t CFile::write(const uint8_t * ptr, size_t size) {
if(iFd >= 0) {
int32_t CFile::write(const uint8_t *ptr, size_t size) {
if (iFd >= 0) {
size_t done = 0;
while(done < size) {
while (done < size) {
int32_t ret = ::write(iFd, ptr, size - done);
if(ret <= 0)
if (ret <= 0)
return ret;
ptr += ret;
@ -130,25 +130,25 @@ int32_t CFile::seek(long int offset, int32_t origin) {
int32_t ret = 0;
int64_t newPos = pos;
if(origin == SEEK_SET) {
if (origin == SEEK_SET) {
newPos = offset;
} else if(origin == SEEK_CUR) {
} else if (origin == SEEK_CUR) {
newPos += offset;
} else if(origin == SEEK_END) {
newPos = filesize+offset;
} else if (origin == SEEK_END) {
newPos = filesize + offset;
}
if(newPos < 0) {
if (newPos < 0) {
pos = 0;
} else {
pos = newPos;
}
if(iFd >= 0)
if (iFd >= 0)
ret = ::lseek(iFd, pos, SEEK_SET);
if(mem_file != NULL) {
if(pos > filesize) {
if (mem_file != NULL) {
if (pos > filesize) {
pos = filesize;
}
}
@ -163,8 +163,8 @@ int32_t CFile::fwrite(const char *format, ...) {
va_list va;
va_start(va, format);
if((vsprintf(tmp, format, va) >= 0)) {
result = this->write((uint8_t *)tmp, strlen(tmp));
if ((vsprintf(tmp, format, va) >= 0)) {
result = this->write((uint8_t *) tmp, strlen(tmp));
}
va_end(va);

28
source/fs/CFile.hpp
View File

@ -18,18 +18,22 @@ public:
};
CFile();
CFile(const std::string & filepath, eOpenTypes mode);
CFile(const uint8_t * memory, int32_t memsize);
CFile(const std::string &filepath, eOpenTypes mode);
CFile(const uint8_t *memory, int32_t memsize);
virtual ~CFile();
int32_t open(const std::string & filepath, eOpenTypes mode);
int32_t open(const uint8_t * memory, int32_t memsize);
int32_t open(const std::string &filepath, eOpenTypes mode);
int32_t open(const uint8_t *memory, int32_t memsize);
BOOL isOpen() const {
if(iFd >= 0)
if (iFd >= 0)
return true;
if(mem_file)
if (mem_file)
return true;
return false;
@ -37,23 +41,29 @@ public:
void close();
int32_t read(uint8_t * ptr, size_t size);
int32_t write(const uint8_t * ptr, size_t size);
int32_t read(uint8_t *ptr, size_t size);
int32_t write(const uint8_t *ptr, size_t size);
int32_t fwrite(const char *format, ...);
int32_t seek(long int offset, int32_t origin);
uint64_t tell() {
return pos;
};
uint64_t size() {
return filesize;
};
void rewind() {
this->seek(0, SEEK_SET);
};
protected:
int32_t iFd;
const uint8_t * mem_file;
const uint8_t *mem_file;
uint64_t filesize;
uint64_t pos;
};

127
source/gui/FreeTypeGX.cpp
View File

@ -31,14 +31,14 @@ using namespace std;
/**
* Default constructor for the FreeTypeGX class for WiiXplorer.
*/
FreeTypeGX::FreeTypeGX(const uint8_t* fontBuffer, FT_Long bufferSize, bool lastFace) {
FreeTypeGX::FreeTypeGX(const uint8_t *fontBuffer, FT_Long bufferSize, bool lastFace) {
int32_t faceIndex = 0;
ftPointSize = 0;
GX2InitSampler(&ftSampler, GX2_TEX_CLAMP_MODE_CLAMP_BORDER, GX2_TEX_XY_FILTER_MODE_LINEAR);
FT_Init_FreeType(&ftLibrary);
if(lastFace) {
FT_New_Memory_Face(ftLibrary, (FT_Byte *)fontBuffer, bufferSize, -1, &ftFace);
if (lastFace) {
FT_New_Memory_Face(ftLibrary, (FT_Byte *) fontBuffer, bufferSize, -1, &ftFace);
faceIndex = ftFace->num_faces - 1; // Use the last face
FT_Done_Face(ftFace);
ftFace = NULL;
@ -67,10 +67,10 @@ FreeTypeGX::~FreeTypeGX() {
* @return Wide character representation of supplied character string.
*/
wchar_t* FreeTypeGX::charToWideChar(const char* strChar) {
wchar_t *FreeTypeGX::charToWideChar(const char *strChar) {
if (!strChar) return NULL;
wchar_t *strWChar = new (std::nothrow) wchar_t[strlen(strChar) + 1];
wchar_t *strWChar = new(std::nothrow) wchar_t[strlen(strChar) + 1];
if (!strWChar) return NULL;
int32_t bt = mbstowcs(strWChar, strChar, strlen(strChar));
@ -80,14 +80,13 @@ wchar_t* FreeTypeGX::charToWideChar(const char* strChar) {
}
wchar_t *tempDest = strWChar;
while ((*tempDest++ = *strChar++))
;
while ((*tempDest++ = *strChar++));
return strWChar;
}
char *FreeTypeGX::wideCharToUTF8(const wchar_t* strChar) {
if(!strChar) {
char *FreeTypeGX::wideCharToUTF8(const wchar_t *strChar) {
if (!strChar) {
return NULL;
}
@ -106,8 +105,8 @@ char *FreeTypeGX::wideCharToUTF8(const wchar_t* strChar) {
len += 4;
}
char *pOut = new (std::nothrow) char[len];
if(!pOut)
char *pOut = new(std::nothrow) char[len];
if (!pOut)
return NULL;
size_t n = 0;
@ -115,19 +114,19 @@ char *FreeTypeGX::wideCharToUTF8(const wchar_t* strChar) {
for (size_t i = 0; strChar[i]; ++i) {
wc = strChar[i];
if (wc < 0x80)
pOut[n++] = (char)wc;
pOut[n++] = (char) wc;
else if (wc < 0x800) {
pOut[n++] = (char)((wc >> 6) | 0xC0);
pOut[n++] = (char)((wc & 0x3F) | 0x80);
pOut[n++] = (char) ((wc >> 6) | 0xC0);
pOut[n++] = (char) ((wc & 0x3F) | 0x80);
} else if (wc < 0x10000) {
pOut[n++] = (char)((wc >> 12) | 0xE0);
pOut[n++] = (char)(((wc >> 6) & 0x3F) | 0x80);
pOut[n++] = (char)((wc & 0x3F) | 0x80);
pOut[n++] = (char) ((wc >> 12) | 0xE0);
pOut[n++] = (char) (((wc >> 6) & 0x3F) | 0x80);
pOut[n++] = (char) ((wc & 0x3F) | 0x80);
} else {
pOut[n++] = (char)(((wc >> 18) & 0x07) | 0xF0);
pOut[n++] = (char)(((wc >> 12) & 0x3F) | 0x80);
pOut[n++] = (char)(((wc >> 6) & 0x3F) | 0x80);
pOut[n++] = (char)((wc & 0x3F) | 0x80);
pOut[n++] = (char) (((wc >> 18) & 0x07) | 0xF0);
pOut[n++] = (char) (((wc >> 12) & 0x3F) | 0x80);
pOut[n++] = (char) (((wc >> 6) & 0x3F) | 0x80);
pOut[n++] = (char) ((wc & 0x3F) | 0x80);
}
}
return pOut;
@ -139,13 +138,13 @@ char *FreeTypeGX::wideCharToUTF8(const wchar_t* strChar) {
* This routine clears all members of the font map structure and frees all allocated memory back to the system.
*/
void FreeTypeGX::unloadFont() {
map<int16_t, ftGX2Data >::iterator itr;
map<int16_t, ftGX2Data>::iterator itr;
map<wchar_t, ftgxCharData>::iterator itr2;
for (itr = fontData.begin(); itr != fontData.end(); itr++) {
for (itr2 = itr->second.ftgxCharMap.begin(); itr2 != itr->second.ftgxCharMap.end(); itr2++) {
if(itr2->second.texture) {
if(itr2->second.texture->surface.image)
if (itr2->second.texture) {
if (itr2->second.texture->surface.image)
free(itr2->second.texture->surface.image);
delete itr2->second.texture;
@ -166,7 +165,7 @@ void FreeTypeGX::unloadFont() {
* @param charCode The requested glyph's character code.
* @return A pointer to the allocated font structure.
*/
ftgxCharData * FreeTypeGX::cacheGlyphData(wchar_t charCode, int16_t pixelSize) {
ftgxCharData *FreeTypeGX::cacheGlyphData(wchar_t charCode, int16_t pixelSize) {
map<int16_t, ftGX2Data>::iterator itr = fontData.find(pixelSize);
if (itr != fontData.end()) {
map<wchar_t, ftgxCharData>::iterator itr2 = itr->second.ftgxCharMap.find(charCode);
@ -195,9 +194,9 @@ ftgxCharData * FreeTypeGX::cacheGlyphData(wchar_t charCode, int16_t pixelSize) {
textureWidth = ALIGN4(glyphBitmap->width);
textureHeight = ALIGN4(glyphBitmap->rows);
if(textureWidth == 0)
if (textureWidth == 0)
textureWidth = 4;
if(textureHeight == 0)
if (textureHeight == 0)
textureHeight = 4;
ftgxCharData *charData = &ftData->ftgxCharMap[charCode];
@ -211,7 +210,7 @@ ftgxCharData * FreeTypeGX::cacheGlyphData(wchar_t charCode, int16_t pixelSize) {
//! Initialize texture
charData->texture = new GX2Texture;
GX2InitTexture(charData->texture, textureWidth, textureHeight, 1, 0, GX2_SURFACE_FORMAT_UNORM_R5_G5_B5_A1, GX2_SURFACE_DIM_TEXTURE_2D, GX2_TILE_MODE_LINEAR_ALIGNED);
GX2InitTexture(charData->texture, textureWidth, textureHeight, 1, 0, GX2_SURFACE_FORMAT_UNORM_R5_G5_B5_A1, GX2_SURFACE_DIM_TEXTURE_2D, GX2_TILE_MODE_LINEAR_ALIGNED);
loadGlyphData(glyphBitmap, charData);
@ -251,17 +250,17 @@ uint16_t FreeTypeGX::cacheGlyphDataComplete(int16_t pixelSize) {
void FreeTypeGX::loadGlyphData(FT_Bitmap *bmp, ftgxCharData *charData) {
charData->texture->surface.image = (uint8_t *) memalign(charData->texture->surface.alignment, charData->texture->surface.imageSize);
if(!charData->texture->surface.image)
if (!charData->texture->surface.image)
return;
memset(charData->texture->surface.image, 0x00, charData->texture->surface.imageSize);
uint8_t *src = (uint8_t *)bmp->buffer;
uint16_t *dst = (uint16_t *)charData->texture->surface.image;
uint8_t *src = (uint8_t *) bmp->buffer;
uint16_t *dst = (uint16_t *) charData->texture->surface.image;
uint32_t x, y;
for(y = 0; y < bmp->rows; y++) {
for(x = 0; x < bmp->width; x++) {
for (y = 0; y < bmp->rows; y++) {
for (x = 0; x < bmp->width; x++) {
uint8_t intensity = src[y * bmp->width + x] >> 3;
dst[y * charData->texture->surface.pitch + x] = intensity ? ((intensity << 11) | (intensity << 6) | (intensity << 1) | 1) : 0;
}
@ -299,27 +298,27 @@ int16_t FreeTypeGX::getStyleOffsetHeight(int16_t format, uint16_t pixelSize) {
if (itr == fontData.end()) return 0;
switch (format & FTGX_ALIGN_MASK) {
case FTGX_ALIGN_TOP:
return itr->second.ftgxAlign.descender;
case FTGX_ALIGN_TOP:
return itr->second.ftgxAlign.descender;
case FTGX_ALIGN_MIDDLE:
default:
return (itr->second.ftgxAlign.ascender + itr->second.ftgxAlign.descender + 1) >> 1;
case FTGX_ALIGN_MIDDLE:
default:
return (itr->second.ftgxAlign.ascender + itr->second.ftgxAlign.descender + 1) >> 1;
case FTGX_ALIGN_BOTTOM:
return itr->second.ftgxAlign.ascender;
case FTGX_ALIGN_BOTTOM:
return itr->second.ftgxAlign.ascender;
case FTGX_ALIGN_BASELINE:
return 0;
case FTGX_ALIGN_BASELINE:
return 0;
case FTGX_ALIGN_GLYPH_TOP:
return itr->second.ftgxAlign.max;
case FTGX_ALIGN_GLYPH_TOP:
return itr->second.ftgxAlign.max;
case FTGX_ALIGN_GLYPH_MIDDLE:
return (itr->second.ftgxAlign.max + itr->second.ftgxAlign.min + 1) >> 1;
case FTGX_ALIGN_GLYPH_MIDDLE:
return (itr->second.ftgxAlign.max + itr->second.ftgxAlign.min + 1) >> 1;
case FTGX_ALIGN_GLYPH_BOTTOM:
return itr->second.ftgxAlign.min;
case FTGX_ALIGN_GLYPH_BOTTOM:
return itr->second.ftgxAlign.min;
}
return 0;
}
@ -338,7 +337,8 @@ int16_t FreeTypeGX::getStyleOffsetHeight(int16_t format, uint16_t pixelSize) {
* @return The number of characters printed.
*/
uint16_t FreeTypeGX::drawText(CVideo *video, int16_t x, int16_t y, int16_t z, const wchar_t *text, int16_t pixelSize, const glm::vec4 & color, uint16_t textStyle, uint16_t textWidth, const float &textBlur, const float & colorBlurIntensity, const glm::vec4 & blurColor, const float & internalRenderingScale) {
uint16_t FreeTypeGX::drawText(CVideo *video, int16_t x, int16_t y, int16_t z, const wchar_t *text, int16_t pixelSize, const glm::vec4 &color, uint16_t textStyle, uint16_t textWidth, const float &textBlur, const float &colorBlurIntensity,
const glm::vec4 &blurColor, const float &internalRenderingScale) {
if (!text)
return 0;
@ -356,7 +356,7 @@ uint16_t FreeTypeGX::drawText(CVideo *video, int16_t x, int16_t y, int16_t z, co
int32_t i = 0;
while (text[i]) {
ftgxCharData* glyphData = cacheGlyphData(text[i], pixelSize);
ftgxCharData *glyphData = cacheGlyphData(text[i], pixelSize);
if (glyphData != NULL) {
if (ftKerningEnabled && i > 0) {
@ -364,7 +364,7 @@ uint16_t FreeTypeGX::drawText(CVideo *video, int16_t x, int16_t y, int16_t z, co
x_pos += (pairDelta.x >> 6);
}
copyTextureToFramebuffer(video, glyphData->texture,x_pos + glyphData->renderOffsetX + x_offset, y + glyphData->renderOffsetY - y_offset, z, color, textBlur, colorBlurIntensity, blurColor,internalRenderingScale);
copyTextureToFramebuffer(video, glyphData->texture, x_pos + glyphData->renderOffsetX + x_offset, y + glyphData->renderOffsetY - y_offset, z, color, textBlur, colorBlurIntensity, blurColor, internalRenderingScale);
x_pos += glyphData->glyphAdvanceX;
++printed;
@ -393,7 +393,7 @@ uint16_t FreeTypeGX::getWidth(const wchar_t *text, int16_t pixelSize) {
int32_t i = 0;
while (text[i]) {
ftgxCharData* glyphData = cacheGlyphData(text[i], pixelSize);
ftgxCharData *glyphData = cacheGlyphData(text[i], pixelSize);
if (glyphData != NULL) {
if (ftKerningEnabled && (i > 0)) {
@ -413,7 +413,7 @@ uint16_t FreeTypeGX::getWidth(const wchar_t *text, int16_t pixelSize) {
*/
uint16_t FreeTypeGX::getCharWidth(const wchar_t wChar, int16_t pixelSize, const wchar_t prevChar) {
uint16_t strWidth = 0;
ftgxCharData * glyphData = cacheGlyphData(wChar, pixelSize);
ftgxCharData *glyphData = cacheGlyphData(wChar, pixelSize);
if (glyphData != NULL) {
if (ftKerningEnabled && prevChar != 0x0000) {
@ -463,7 +463,7 @@ void FreeTypeGX::getOffset(const wchar_t *text, int16_t pixelSize, uint16_t widt
while (text[i]) {
if (widthLimit > 0 && currWidth >= widthLimit) break;
ftgxCharData* glyphData = cacheGlyphData(text[i], pixelSize);
ftgxCharData *glyphData = cacheGlyphData(text[i], pixelSize);
if (glyphData != NULL) {
strMax = glyphData->renderOffsetMax > strMax ? glyphData->renderOffsetMax : strMax;
@ -497,20 +497,21 @@ void FreeTypeGX::getOffset(const wchar_t *text, int16_t pixelSize, uint16_t widt
* @param screenY The screen Y coordinate at which to output the rendered texture.
* @param color Color to apply to the texture.
*/
void FreeTypeGX::copyTextureToFramebuffer(CVideo *pVideo, GX2Texture *texture, int16_t x, int16_t y, int16_t z, const glm::vec4 & color, const float & defaultBlur, const float & blurIntensity, const glm::vec4 & blurColor, const float & internalRenderingScale) {
void FreeTypeGX::copyTextureToFramebuffer(CVideo *pVideo, GX2Texture *texture, int16_t x, int16_t y, int16_t z, const glm::vec4 &color, const float &defaultBlur, const float &blurIntensity, const glm::vec4 &blurColor,
const float &internalRenderingScale) {
static const float imageAngle = 0.0f;
static const float blurScale = (2.0f/ (internalRenderingScale));
static const float blurScale = (2.0f / (internalRenderingScale));
float offsetLeft = blurScale * ((float)x + 0.5f * (float)texture->surface.width) * (float)pVideo->getWidthScaleFactor();
float offsetTop = blurScale * ((float)y - 0.5f * (float)texture->surface.height) * (float)pVideo->getHeightScaleFactor();
float offsetLeft = blurScale * ((float) x + 0.5f * (float) texture->surface.width) * (float) pVideo->getWidthScaleFactor();
float offsetTop = blurScale * ((float) y - 0.5f * (float) texture->surface.height) * (float) pVideo->getHeightScaleFactor();
float widthScale = blurScale * (float)texture->surface.width * pVideo->getWidthScaleFactor();
float heightScale = blurScale * (float)texture->surface.height * pVideo->getHeightScaleFactor();
float widthScale = blurScale * (float) texture->surface.width * pVideo->getWidthScaleFactor();
float heightScale = blurScale * (float) texture->surface.height * pVideo->getHeightScaleFactor();
glm::vec3 positionOffsets( offsetLeft, offsetTop, (float)z );
glm::vec3 positionOffsets(offsetLeft, offsetTop, (float) z);
//! blur doubles due to blur we have to scale the texture
glm::vec3 scaleFactor( widthScale, heightScale, 1.0f );
glm::vec3 scaleFactor(widthScale, heightScale, 1.0f);
glm::vec3 blurDirection;
blurDirection[2] = 1.0f;
@ -522,7 +523,7 @@ void FreeTypeGX::copyTextureToFramebuffer(CVideo *pVideo, GX2Texture *texture, i
Texture2DShader::instance()->setScale(scaleFactor);
Texture2DShader::instance()->setTextureAndSampler(texture, &ftSampler);
if(blurIntensity > 0.0f) {
if (blurIntensity > 0.0f) {
//! glow blur color
Texture2DShader::instance()->setColorIntensity(blurColor);

14
source/gui/GameBgImage.cpp
View File

@ -2,8 +2,8 @@
#include <gui/video/CVideo.h>
#include <gui/video/shaders/Shader3D.h>
GameBgImage::GameBgImage(const std::string & filename, GuiImageData *preloadImage)
: GuiImageAsync(filename, preloadImage) {
GameBgImage::GameBgImage(const std::string &filename, GuiImageData *preloadImage)
: GuiImageAsync(filename, preloadImage) {
identity = glm::mat4(1.0f);
alphaFadeOut = glm::vec4(1.0f, 0.075f, 5.305f, 2.0f);
}
@ -12,18 +12,18 @@ GameBgImage::~GameBgImage() {
}
void GameBgImage::draw(CVideo *pVideo) {
if(!getImageData() || !getImageData()->getTexture())
if (!getImageData() || !getImageData()->getTexture())
return;
//! first setup 2D GUI positions
float currPosX = getCenterX();
float currPosY = getCenterY();
float currPosZ = getDepth();
float currScaleX = getScaleX() * (float)getWidth() * pVideo->getWidthScaleFactor();
float currScaleY = getScaleY() * (float)getHeight() * pVideo->getHeightScaleFactor();
float currScaleZ = getScaleZ() * (float)getWidth() * pVideo->getDepthScaleFactor();
float currScaleX = getScaleX() * (float) getWidth() * pVideo->getWidthScaleFactor();
float currScaleY = getScaleY() * (float) getHeight() * pVideo->getHeightScaleFactor();
float currScaleZ = getScaleZ() * (float) getWidth() * pVideo->getDepthScaleFactor();
glm::mat4 m_modelView = glm::translate(identity, glm::vec3(currPosX,currPosY, currPosZ));
glm::mat4 m_modelView = glm::translate(identity, glm::vec3(currPosX, currPosY, currPosZ));
m_modelView = glm::scale(m_modelView, glm::vec3(currScaleX, currScaleY, currScaleZ));
Shader3D::instance()->setShaders();

40
source/gui/GridBackground.cpp
View File

@ -7,7 +7,7 @@ static const float bgRepeat = 1000.0f;
static const float bgTexRotate = 39.0f;
GridBackground::GridBackground(GuiImageData *img)
: GuiImage(img) {
: GuiImage(img) {
colorIntensity = glm::vec4(1.0f, 1.0f, 1.0f, 0.9f);
alphaFadeOut = glm::vec4(0.0f);
distanceFadeOut = 0.15f;
@ -15,18 +15,18 @@ GridBackground::GridBackground(GuiImageData *img)
vtxCount = 4;
//! texture and vertex coordinates
float *m_posVtxs = (float*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, vtxCount * Shader3D::cuVertexAttrSize);
float *m_texCoords = (float*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, vtxCount * Shader3D::cuTexCoordAttrSize);
float *m_posVtxs = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, vtxCount * Shader3D::cuVertexAttrSize);
float *m_texCoords = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, vtxCount * Shader3D::cuTexCoordAttrSize);
if(m_posVtxs) {
if (m_posVtxs) {
int32_t i = 0;
m_posVtxs[i++] = -1.0f;
m_posVtxs[i++] = 0.0f;
m_posVtxs[i++] = 1.0f;
m_posVtxs[i++] = 1.0f;
m_posVtxs[i++] = 1.0f;
m_posVtxs[i++] = 0.0f;
m_posVtxs[i++] = 1.0f;
m_posVtxs[i++] = 1.0f;
m_posVtxs[i++] = 1.0f;
m_posVtxs[i++] = 0.0f;
m_posVtxs[i++] = -1.0f;
m_posVtxs[i++] = -1.0f;
@ -35,7 +35,7 @@ GridBackground::GridBackground(GuiImageData *img)
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, m_posVtxs, vtxCount * Shader3D::cuVertexAttrSize);
}
if(m_texCoords) {
if (m_texCoords) {
glm::vec2 texCoordVec[4];
texCoordVec[0][0] = -0.5f * bgRepeat;
texCoordVec[0][1] = 0.5f * bgRepeat;
@ -50,14 +50,14 @@ GridBackground::GridBackground(GuiImageData *img)
const float sinRot = sinf(DegToRad(bgTexRotate));
glm::mat2 texRotateMtx({
cosRot, -sinRot,
sinRot, cosRot
});
cosRot, -sinRot,
sinRot, cosRot
});
for(int32_t i = 0; i < 4; i++) {
for (int32_t i = 0; i < 4; i++) {
texCoordVec[i] = texRotateMtx * texCoordVec[i];
m_texCoords[i*2 + 0] = texCoordVec[i][0];
m_texCoords[i*2 + 1] = texCoordVec[i][1];
m_texCoords[i * 2 + 0] = texCoordVec[i][0];
m_texCoords[i * 2 + 1] = texCoordVec[i][1];
}
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, m_texCoords, vtxCount * Shader3D::cuTexCoordAttrSize);
@ -73,21 +73,21 @@ GridBackground::~GridBackground() {
imageData = NULL;
//! main image vertexes
if(posVtxs) {
free((void*)posVtxs);
if (posVtxs) {
free((void *) posVtxs);
posVtxs = NULL;
}
if(texCoords) {
free((void*)texCoords);
if (texCoords) {
free((void *) texCoords);
texCoords = NULL;
}
}
void GridBackground::draw(CVideo *pVideo, const glm::mat4 & modelView) {
void GridBackground::draw(CVideo *pVideo, const glm::mat4 &modelView) {
//! first setup 2D GUI positions
float currScaleX = bgRepeat * scaleX * (float)getWidth() * pVideo->getWidthScaleFactor();
float currScaleX = bgRepeat * scaleX * (float) getWidth() * pVideo->getWidthScaleFactor();
float currScaleY = 1.0f;
float currScaleZ = bgRepeat * scaleZ * (float)getHeight() * pVideo->getDepthScaleFactor();
float currScaleZ = bgRepeat * scaleZ * (float) getHeight() * pVideo->getDepthScaleFactor();
m_modelView = glm::scale(modelView, glm::vec3(currScaleX, currScaleY, currScaleZ));

161
source/gui/GuiButton.cpp
View File

@ -32,13 +32,13 @@ GuiButton::GuiButton(float w, float h) {
icon = NULL;
iconOver = NULL;
for(int32_t i = 0; i < 4; i++) {
for (int32_t i = 0; i < 4; i++) {
label[i] = NULL;
labelOver[i] = NULL;
labelHold[i] = NULL;
labelClick[i] = NULL;
}
for(int32_t i = 0; i < iMaxGuiTriggers; i++) {
for (int32_t i = 0; i < iMaxGuiTriggers; i++) {
trigger[i] = NULL;
}
@ -58,64 +58,74 @@ GuiButton::GuiButton(float w, float h) {
GuiButton::~GuiButton() {
}
void GuiButton::setImage(GuiImage* img) {
void GuiButton::setImage(GuiImage *img) {
image = img;
if(img) img->setParent(this);
}
void GuiButton::setImageOver(GuiImage* img) {
imageOver = img;
if(img) img->setParent(this);
}
void GuiButton::setImageHold(GuiImage* img) {
imageHold = img;
if(img) img->setParent(this);
}
void GuiButton::setImageClick(GuiImage* img) {
imageClick = img;
if(img) img->setParent(this);
}
void GuiButton::setIcon(GuiImage* img) {
icon = img;
if(img) img->setParent(this);
}
void GuiButton::setIconOver(GuiImage* img) {
iconOver = img;
if(img) img->setParent(this);
if (img) img->setParent(this);
}
void GuiButton::setLabel(GuiText* txt, int32_t n) {
void GuiButton::setImageOver(GuiImage *img) {
imageOver = img;
if (img) img->setParent(this);
}
void GuiButton::setImageHold(GuiImage *img) {
imageHold = img;
if (img) img->setParent(this);
}
void GuiButton::setImageClick(GuiImage *img) {
imageClick = img;
if (img) img->setParent(this);
}
void GuiButton::setIcon(GuiImage *img) {
icon = img;
if (img) img->setParent(this);
}
void GuiButton::setIconOver(GuiImage *img) {
iconOver = img;
if (img) img->setParent(this);
}
void GuiButton::setLabel(GuiText *txt, int32_t n) {
label[n] = txt;
if(txt) txt->setParent(this);
if (txt) txt->setParent(this);
}
void GuiButton::setLabelOver(GuiText* txt, int32_t n) {
void GuiButton::setLabelOver(GuiText *txt, int32_t n) {
labelOver[n] = txt;
if(txt) txt->setParent(this);
if (txt) txt->setParent(this);
}
void GuiButton::setLabelHold(GuiText* txt, int32_t n) {
void GuiButton::setLabelHold(GuiText *txt, int32_t n) {
labelHold[n] = txt;
if(txt) txt->setParent(this);
if (txt) txt->setParent(this);
}
void GuiButton::setLabelClick(GuiText* txt, int32_t n) {
void GuiButton::setLabelClick(GuiText *txt, int32_t n) {
labelClick[n] = txt;
if(txt) txt->setParent(this);
if (txt) txt->setParent(this);
}
void GuiButton::setSoundOver(GuiSound * snd) {
void GuiButton::setSoundOver(GuiSound *snd) {
soundOver = snd;
}
void GuiButton::setSoundHold(GuiSound * snd) {
void GuiButton::setSoundHold(GuiSound *snd) {
soundHold = snd;
}
void GuiButton::setSoundClick(GuiSound * snd) {
void GuiButton::setSoundClick(GuiSound *snd) {
soundClick = snd;
}
void GuiButton::setTrigger(GuiTrigger * t, int32_t idx) {
if(idx >= 0 && idx < iMaxGuiTriggers) {
void GuiButton::setTrigger(GuiTrigger *t, int32_t idx) {
if (idx >= 0 && idx < iMaxGuiTriggers) {
trigger[idx] = t;
} else {
for(int32_t i = 0; i < iMaxGuiTriggers; i++) {
if(!trigger[i]) {
for (int32_t i = 0; i < iMaxGuiTriggers; i++) {
if (!trigger[i]) {
trigger[i] = t;
break;
}
@ -133,49 +143,49 @@ void GuiButton::resetState(void) {
* Draw the button on screen
*/
void GuiButton::draw(CVideo *v) {
if(!this->isVisible())
if (!this->isVisible())
return;
// draw image
if((isDrawOverOnlyWhenSelected() && (isStateSet(STATE_SELECTED) && imageOver)) ||
(!isDrawOverOnlyWhenSelected() && (isStateSet(STATE_OVER | STATE_SELECTED | STATE_CLICKED | STATE_HELD) && imageOver)))
if ((isDrawOverOnlyWhenSelected() && (isStateSet(STATE_SELECTED) && imageOver)) ||
(!isDrawOverOnlyWhenSelected() && (isStateSet(STATE_OVER | STATE_SELECTED | STATE_CLICKED | STATE_HELD) && imageOver)))
imageOver->draw(v);
else if(image)
else if (image)
image->draw(v);
if((isDrawOverOnlyWhenSelected() && (isStateSet(STATE_SELECTED) && iconOver)) ||
(!isDrawOverOnlyWhenSelected() && (isStateSet(STATE_OVER | STATE_SELECTED | STATE_CLICKED | STATE_HELD) && iconOver)))
if ((isDrawOverOnlyWhenSelected() && (isStateSet(STATE_SELECTED) && iconOver)) ||
(!isDrawOverOnlyWhenSelected() && (isStateSet(STATE_OVER | STATE_SELECTED | STATE_CLICKED | STATE_HELD) && iconOver)))
iconOver->draw(v);
else if(icon)
else if (icon)
icon->draw(v);
// draw text
for(int32_t i = 0; i < 4; i++) {
if(isStateSet(STATE_OVER | STATE_SELECTED | STATE_CLICKED | STATE_HELD) && labelOver[i])
for (int32_t i = 0; i < 4; i++) {
if (isStateSet(STATE_OVER | STATE_SELECTED | STATE_CLICKED | STATE_HELD) && labelOver[i])
labelOver[i]->draw(v);
else if(label[i])
else if (label[i])
label[i]->draw(v);
}
}
void GuiButton::update(GuiController * c) {
if(!c || isStateSet(STATE_DISABLED|STATE_HIDDEN|STATE_DISABLE_INPUT, c->chanIdx))
void GuiButton::update(GuiController *c) {
if (!c || isStateSet(STATE_DISABLED | STATE_HIDDEN | STATE_DISABLE_INPUT, c->chanIdx))
return;
else if(parentElement && (parentElement->isStateSet(STATE_DISABLED|STATE_HIDDEN|STATE_DISABLE_INPUT, c->chanIdx)))
else if (parentElement && (parentElement->isStateSet(STATE_DISABLED | STATE_HIDDEN | STATE_DISABLE_INPUT, c->chanIdx)))
return;
if(selectable) {
if(c->data.validPointer && this->isInside(c->data.x, c->data.y)) {
if(!isStateSet(STATE_OVER, c->chanIdx)) {
if (selectable) {
if (c->data.validPointer && this->isInside(c->data.x, c->data.y)) {
if (!isStateSet(STATE_OVER, c->chanIdx)) {
setState(STATE_OVER, c->chanIdx);
//if(this->isRumbleActive())
// this->rumble(t->chan);
if(soundOver)
if (soundOver)
soundOver->Play();
if(effectsOver && !effects) {
if (effectsOver && !effects) {
// initiate effects
effects = effectsOver;
effectAmount = effectAmountOver;
@ -184,11 +194,11 @@ void GuiButton::update(GuiController * c) {
pointedOn(this, c);
}
} else if(isStateSet(STATE_OVER, c->chanIdx)) {
} else if (isStateSet(STATE_OVER, c->chanIdx)) {
this->clearState(STATE_OVER, c->chanIdx);
pointedOff(this, c);
if(effectTarget == effectTargetOver && effectAmount == effectAmountOver) {
if (effectTarget == effectTargetOver && effectAmount == effectAmountOver) {
// initiate effects (in reverse)
effects = effectsOver;
effectAmount = -effectAmountOver;
@ -197,24 +207,24 @@ void GuiButton::update(GuiController * c) {
}
}
for(int32_t i = 0; i < iMaxGuiTriggers; i++) {
if(!trigger[i])
for (int32_t i = 0; i < iMaxGuiTriggers; i++) {
if (!trigger[i])
continue;
// button triggers
if(clickable) {
if (clickable) {
int32_t isClicked = trigger[i]->clicked(c);
if( !clickedTrigger && (isClicked != GuiTrigger::CLICKED_NONE)
&& (trigger[i]->isClickEverywhere() || (isStateSet(STATE_SELECTED | STATE_OVER, c->chanIdx) && trigger[i]->isSelectionClickEverywhere()) || this->isInside(c->data.x, c->data.y))) {
if(soundClick)
if (!clickedTrigger && (isClicked != GuiTrigger::CLICKED_NONE)
&& (trigger[i]->isClickEverywhere() || (isStateSet(STATE_SELECTED | STATE_OVER, c->chanIdx) && trigger[i]->isSelectionClickEverywhere()) || this->isInside(c->data.x, c->data.y))) {
if (soundClick)
soundClick->Play();
clickedTrigger = trigger[i];
if(!isStateSet(STATE_CLICKED, c->chanIdx)) {
if(isClicked == GuiTrigger::CLICKED_TOUCH) {
if (!isStateSet(STATE_CLICKED, c->chanIdx)) {
if (isClicked == GuiTrigger::CLICKED_TOUCH) {
setState(STATE_CLICKED_TOUCH, c->chanIdx);
} else {
setState(STATE_CLICKED, c->chanIdx);
@ -222,8 +232,9 @@ void GuiButton::update(GuiController * c) {
}
clicked(this, c, trigger[i]);
} else if((isStateSet(STATE_CLICKED, c->chanIdx) || isStateSet(STATE_CLICKED_TOUCH, c->chanIdx)) && (clickedTrigger == trigger[i]) && !isStateSet(STATE_HELD, c->chanIdx) && !trigger[i]->held(c) && ((isClicked == GuiTrigger::CLICKED_NONE) || trigger[i]->released(c))) {
if((isStateSet(STATE_CLICKED_TOUCH, c->chanIdx) && this->isInside(c->data.x, c->data.y)) || (isStateSet(STATE_CLICKED, c->chanIdx))) {
} else if ((isStateSet(STATE_CLICKED, c->chanIdx) || isStateSet(STATE_CLICKED_TOUCH, c->chanIdx)) && (clickedTrigger == trigger[i]) && !isStateSet(STATE_HELD, c->chanIdx) && !trigger[i]->held(c) &&
((isClicked == GuiTrigger::CLICKED_NONE) || trigger[i]->released(c))) {
if ((isStateSet(STATE_CLICKED_TOUCH, c->chanIdx) && this->isInside(c->data.x, c->data.y)) || (isStateSet(STATE_CLICKED, c->chanIdx))) {
clickedTrigger = NULL;
clearState(STATE_CLICKED, c->chanIdx);
released(this, c, trigger[i]);
@ -231,20 +242,20 @@ void GuiButton::update(GuiController * c) {
}
}
if(holdable) {
if (holdable) {
bool isHeld = trigger[i]->held(c);
if( (!heldTrigger || heldTrigger == trigger[i]) && isHeld
&& (trigger[i]->isHoldEverywhere() || (isStateSet(STATE_SELECTED | STATE_OVER, c->chanIdx) && trigger[i]->isSelectionClickEverywhere()) || this->isInside(c->data.x, c->data.y))) {
if ((!heldTrigger || heldTrigger == trigger[i]) && isHeld
&& (trigger[i]->isHoldEverywhere() || (isStateSet(STATE_SELECTED | STATE_OVER, c->chanIdx) && trigger[i]->isSelectionClickEverywhere()) || this->isInside(c->data.x, c->data.y))) {
heldTrigger = trigger[i];
if(!isStateSet(STATE_HELD, c->chanIdx))
if (!isStateSet(STATE_HELD, c->chanIdx))
setState(STATE_HELD, c->chanIdx);
held(this, c, trigger[i]);
} else if(isStateSet(STATE_HELD, c->chanIdx) && (heldTrigger == trigger[i]) && (!isHeld || trigger[i]->released(c))) {
} else if (isStateSet(STATE_HELD, c->chanIdx) && (heldTrigger == trigger[i]) && (!isHeld || trigger[i]->released(c))) {
//! click is removed at this point and converted to held
if(clickedTrigger == trigger[i]) {
if (clickedTrigger == trigger[i]) {
clickedTrigger = NULL;
clearState(STATE_CLICKED, c->chanIdx);
}

23
source/gui/GuiCheckBox.cpp
View File

@ -17,12 +17,13 @@
#include <gui/GuiCheckBox.h>
#include <gui/GuiImage.h>
#include <gui/GuiImageData.h>
/**
* Constructor for the GuiCheckBox class.
*/
GuiCheckBox::GuiCheckBox(GuiImage * background, bool checked, float width,float height)
: GuiToggle(checked,width,height) {
GuiCheckBox::GuiCheckBox(GuiImage *background, bool checked, float width, float height)
: GuiToggle(checked, width, height) {
setImageBackground(background);
}
@ -33,31 +34,31 @@ GuiCheckBox::~GuiCheckBox() {
}
void GuiCheckBox::setImageBackground(GuiImage* img) {
void GuiCheckBox::setImageBackground(GuiImage *img) {
backgroundImg = img;
if(img) {
if (img) {
img->setParent(this);
}
}
void GuiCheckBox::setImageSelected(GuiImage* img) {
void GuiCheckBox::setImageSelected(GuiImage *img) {
selectedImg = img;
if(img) {
if (img) {
img->setParent(this);
}
}
void GuiCheckBox::setImageHighlighted(GuiImage* img) {
void GuiCheckBox::setImageHighlighted(GuiImage *img) {
highlightedImg = img;
if(img) {
if (img) {
img->setParent(this);
}
setIconOver(img);
}
void GuiCheckBox::update(GuiController * c) {
if(bChanged) {
if(selected) {
void GuiCheckBox::update(GuiController *c) {
if (bChanged) {
if (selected) {
GuiButton::setImage(selectedImg);
} else {
GuiButton::setImage(backgroundImg);

30
source/gui/GuiDragListener.cpp
View File

@ -22,10 +22,10 @@
* Constructor for the GuiDragListener class.
*/
GuiDragListener::GuiDragListener(float w,float h) {
GuiDragListener::GuiDragListener(float w, float h) {
width = w;
height = h;
for(int32_t i = 0; i < iMaxGuiTriggers; i++) {
for (int32_t i = 0; i < iMaxGuiTriggers; i++) {
trigger[i] = NULL;
}
}
@ -37,15 +37,15 @@ GuiDragListener::~GuiDragListener() {
}
void GuiDragListener::setState(int32_t i, int32_t c) {
GuiElement::setState(i,c);
GuiElement::setState(i, c);
}
void GuiDragListener::setTrigger(GuiTrigger * t, int32_t idx) {
if(idx >= 0 && idx < iMaxGuiTriggers) {
void GuiDragListener::setTrigger(GuiTrigger *t, int32_t idx) {
if (idx >= 0 && idx < iMaxGuiTriggers) {
trigger[idx] = t;
} else {
for(int32_t i = 0; i < iMaxGuiTriggers; i++) {
if(!trigger[i]) {
for (int32_t i = 0; i < iMaxGuiTriggers; i++) {
if (!trigger[i]) {
trigger[i] = t;
break;
}
@ -53,27 +53,27 @@ void GuiDragListener::setTrigger(GuiTrigger * t, int32_t idx) {
}
}
void GuiDragListener::update(GuiController * c) {
if(!c || isStateSet(STATE_DISABLED|STATE_HIDDEN|STATE_DISABLE_INPUT, c->chanIdx))
void GuiDragListener::update(GuiController *c) {
if (!c || isStateSet(STATE_DISABLED | STATE_HIDDEN | STATE_DISABLE_INPUT, c->chanIdx))
return;
else if(parentElement && (parentElement->isStateSet(STATE_DISABLED|STATE_HIDDEN|STATE_DISABLE_INPUT, c->chanIdx)))
else if (parentElement && (parentElement->isStateSet(STATE_DISABLED | STATE_HIDDEN | STATE_DISABLE_INPUT, c->chanIdx)))
return;
for(int32_t i = 0; i < iMaxGuiTriggers; i++) {
if(!trigger[i]) {
for (int32_t i = 0; i < iMaxGuiTriggers; i++) {
if (!trigger[i]) {
continue;
}
bool isHeld = trigger[i]->held(c);
if(isHeld && this->isInside(c->data.x, c->data.y)) {
if (isHeld && this->isInside(c->data.x, c->data.y)) {
int32_t dx = c->data.x - c->lastData.x;
int32_t dy = c->data.y - c->lastData.y;
if(dx == 0 && dy == 0) continue;
if (dx == 0 && dy == 0) continue;
dragged(this, c, trigger[i],dx,dy);
dragged(this, c, trigger[i], dx, dy);
}
}
}

103
source/gui/GuiElement.cpp
View File

@ -33,7 +33,7 @@ GuiElement::GuiElement() {
scaleX = 1.0f;
scaleY = 1.0f;
scaleZ = 1.0f;
for(int32_t i = 0; i < 5; i++)
for (int32_t i = 0; i < 5; i++)
state[i] = STATE_DEFAULT;
stateChan = -1;
parentElement = NULL;
@ -69,7 +69,7 @@ float GuiElement::getLeft() {
float pLeft = 0;
float pScaleX = 1.0f;
if(parentElement) {
if (parentElement) {
pWidth = parentElement->getWidth();
pLeft = parentElement->getLeft();
pScaleX = parentElement->getScaleX();
@ -80,9 +80,9 @@ float GuiElement::getLeft() {
float x = pLeft;
//! TODO: the conversion from int to float and back to int is bad for performance, change that
if(alignment & ALIGN_CENTER) {
if (alignment & ALIGN_CENTER) {
x = pLeft + pWidth * 0.5f * pScaleX - width * 0.5f * getScaleX();
} else if(alignment & ALIGN_RIGHT) {
} else if (alignment & ALIGN_RIGHT) {
x = pLeft + pWidth * pScaleX - width * getScaleX();
}
@ -99,7 +99,7 @@ float GuiElement::getTop() {
float pTop = 0;
float pScaleY = 1.0f;
if(parentElement) {
if (parentElement) {
pHeight = parentElement->getHeight();
pTop = parentElement->getTop();
pScaleY = parentElement->getScaleY();
@ -110,9 +110,9 @@ float GuiElement::getTop() {
float y = pTop;
//! TODO: the conversion from int to float and back to int is bad for performance, change that
if(alignment & ALIGN_MIDDLE) {
if (alignment & ALIGN_MIDDLE) {
y = pTop + pHeight * 0.5f * pScaleY - getHeight() * 0.5f * getScaleY();
} else if(alignment & ALIGN_BOTTOM) {
} else if (alignment & ALIGN_BOTTOM) {
y = pTop + pHeight * pScaleY - getHeight() * getScaleY();
}
@ -120,33 +120,33 @@ float GuiElement::getTop() {
}
void GuiElement::setEffect(int32_t eff, int32_t amount, int32_t target) {
if(eff & EFFECT_SLIDE_IN) {
if (eff & EFFECT_SLIDE_IN) {
// these calculations overcompensate a little
if(eff & EFFECT_SLIDE_TOP) {
if(eff & EFFECT_SLIDE_FROM)
yoffsetDyn = (int32_t) -getHeight()*scaleY;
if (eff & EFFECT_SLIDE_TOP) {
if (eff & EFFECT_SLIDE_FROM)
yoffsetDyn = (int32_t) -getHeight() * scaleY;
else
yoffsetDyn = -screenheight;
} else if(eff & EFFECT_SLIDE_LEFT) {
if(eff & EFFECT_SLIDE_FROM)
xoffsetDyn = (int32_t) -getWidth()*scaleX;
} else if (eff & EFFECT_SLIDE_LEFT) {
if (eff & EFFECT_SLIDE_FROM)
xoffsetDyn = (int32_t) -getWidth() * scaleX;
else
xoffsetDyn = -screenwidth;
} else if(eff & EFFECT_SLIDE_BOTTOM) {
if(eff & EFFECT_SLIDE_FROM)
yoffsetDyn = (int32_t) getHeight()*scaleY;
} else if (eff & EFFECT_SLIDE_BOTTOM) {
if (eff & EFFECT_SLIDE_FROM)
yoffsetDyn = (int32_t) getHeight() * scaleY;
else
yoffsetDyn = screenheight;
} else if(eff & EFFECT_SLIDE_RIGHT) {
if(eff & EFFECT_SLIDE_FROM)
xoffsetDyn = (int32_t) getWidth()*scaleX;
} else if (eff & EFFECT_SLIDE_RIGHT) {
if (eff & EFFECT_SLIDE_FROM)
xoffsetDyn = (int32_t) getWidth() * scaleX;
else
xoffsetDyn = screenwidth;
}
}
if((eff & EFFECT_FADE) && amount > 0) {
if ((eff & EFFECT_FADE) && amount > 0) {
alphaDyn = 0;
} else if((eff & EFFECT_FADE) && amount < 0) {
} else if ((eff & EFFECT_FADE) && amount < 0) {
alphaDyn = alpha;
}
effects |= eff;
@ -176,105 +176,106 @@ void GuiElement::resetEffects() {
effectAmountOver = 0;
effectTargetOver = 0;
}
void GuiElement::updateEffects() {
if(!this->isVisible() && parentElement)
if (!this->isVisible() && parentElement)
return;
if(effects & (EFFECT_SLIDE_IN | EFFECT_SLIDE_OUT | EFFECT_SLIDE_FROM)) {
if(effects & EFFECT_SLIDE_IN) {
if(effects & EFFECT_SLIDE_LEFT) {
if (effects & (EFFECT_SLIDE_IN | EFFECT_SLIDE_OUT | EFFECT_SLIDE_FROM)) {
if (effects & EFFECT_SLIDE_IN) {
if (effects & EFFECT_SLIDE_LEFT) {
xoffsetDyn += effectAmount;
if(xoffsetDyn >= 0) {
if (xoffsetDyn >= 0) {
xoffsetDyn = 0;
effects = 0;
effectFinished(this);
}
} else if(effects & EFFECT_SLIDE_RIGHT) {
} else if (effects & EFFECT_SLIDE_RIGHT) {
xoffsetDyn -= effectAmount;
if(xoffsetDyn <= 0) {
if (xoffsetDyn <= 0) {
xoffsetDyn = 0;
effects = 0;
effectFinished(this);
}
} else if(effects & EFFECT_SLIDE_TOP) {
} else if (effects & EFFECT_SLIDE_TOP) {
yoffsetDyn += effectAmount;
if(yoffsetDyn >= 0) {
if (yoffsetDyn >= 0) {
yoffsetDyn = 0;
effects = 0;
effectFinished(this);
}
} else if(effects & EFFECT_SLIDE_BOTTOM) {
} else if (effects & EFFECT_SLIDE_BOTTOM) {
yoffsetDyn -= effectAmount;
if(yoffsetDyn <= 0) {
if (yoffsetDyn <= 0) {
yoffsetDyn = 0;
effects = 0;
effectFinished(this);
}
}
} else {
if(effects & EFFECT_SLIDE_LEFT) {
if (effects & EFFECT_SLIDE_LEFT) {
xoffsetDyn -= effectAmount;
if(xoffsetDyn <= -screenwidth) {
if (xoffsetDyn <= -screenwidth) {
effects = 0; // shut off effect
effectFinished(this);
} else if((effects & EFFECT_SLIDE_FROM) && xoffsetDyn <= -getWidth()) {
} else if ((effects & EFFECT_SLIDE_FROM) && xoffsetDyn <= -getWidth()) {
effects = 0; // shut off effect
effectFinished(this);
}
} else if(effects & EFFECT_SLIDE_RIGHT) {
} else if (effects & EFFECT_SLIDE_RIGHT) {
xoffsetDyn += effectAmount;
if(xoffsetDyn >= screenwidth) {
if (xoffsetDyn >= screenwidth) {
effects = 0; // shut off effect
effectFinished(this);
} else if((effects & EFFECT_SLIDE_FROM) && xoffsetDyn >= getWidth()*scaleX) {
} else if ((effects & EFFECT_SLIDE_FROM) && xoffsetDyn >= getWidth() * scaleX) {
effects = 0; // shut off effect
effectFinished(this);
}
} else if(effects & EFFECT_SLIDE_TOP) {
} else if (effects & EFFECT_SLIDE_TOP) {
yoffsetDyn -= effectAmount;
if(yoffsetDyn <= -screenheight) {
if (yoffsetDyn <= -screenheight) {
effects = 0; // shut off effect
effectFinished(this);
} else if((effects & EFFECT_SLIDE_FROM) && yoffsetDyn <= -getHeight()) {
} else if ((effects & EFFECT_SLIDE_FROM) && yoffsetDyn <= -getHeight()) {
effects = 0; // shut off effect
effectFinished(this);
}
} else if(effects & EFFECT_SLIDE_BOTTOM) {
} else if (effects & EFFECT_SLIDE_BOTTOM) {
yoffsetDyn += effectAmount;
if(yoffsetDyn >= screenheight) {
if (yoffsetDyn >= screenheight) {
effects = 0; // shut off effect
effectFinished(this);
} else if((effects & EFFECT_SLIDE_FROM) && yoffsetDyn >= getHeight()) {
} else if ((effects & EFFECT_SLIDE_FROM) && yoffsetDyn >= getHeight()) {
effects = 0; // shut off effect
effectFinished(this);
}
}
}
} else if(effects & EFFECT_FADE) {
} else if (effects & EFFECT_FADE) {
alphaDyn += effectAmount * (1.0f / 255.0f);
if(effectAmount < 0 && alphaDyn <= 0) {
if (effectAmount < 0 && alphaDyn <= 0) {
alphaDyn = 0;
effects = 0; // shut off effect
effectFinished(this);
} else if(effectAmount > 0 && alphaDyn >= alpha) {
} else if (effectAmount > 0 && alphaDyn >= alpha) {
alphaDyn = alpha;
effects = 0; // shut off effect
effectFinished(this);
}
} else if(effects & EFFECT_SCALE) {
} else if (effects & EFFECT_SCALE) {
scaleDyn += effectAmount * 0.01f;
if((effectAmount < 0 && scaleDyn <= (effectTarget * 0.01f))
|| (effectAmount > 0 && scaleDyn >= (effectTarget * 0.01f))) {
if ((effectAmount < 0 && scaleDyn <= (effectTarget * 0.01f))
|| (effectAmount > 0 && scaleDyn >= (effectTarget * 0.01f))) {
scaleDyn = effectTarget * 0.01f;
effects = 0; // shut off effect
effectFinished(this);

36
source/gui/GuiFrame.cpp
View File

@ -22,7 +22,7 @@ GuiFrame::GuiFrame(GuiFrame *p) {
height = 0;
dim = false;
if(parent)
if (parent)
parent->append(this);
}
@ -32,18 +32,18 @@ GuiFrame::GuiFrame(float w, float h, GuiFrame *p) {
height = h;
dim = false;
if(parent)
if (parent)
parent->append(this);
}
GuiFrame::~GuiFrame() {
closing(this);
if(parent)
if (parent)
parent->remove(this);
}
void GuiFrame::append(GuiElement* e) {
void GuiFrame::append(GuiElement *e) {
if (e == NULL)
return;
@ -52,22 +52,22 @@ void GuiFrame::append(GuiElement* e) {
e->setParent(this);
}
void GuiFrame::insert(GuiElement* e, uint32_t index) {
void GuiFrame::insert(GuiElement *e, uint32_t index) {
if (e == NULL || (index >= elements.size()))
return;
remove(e);
elements.insert(elements.begin()+index, e);
elements.insert(elements.begin() + index, e);
e->setParent(this);
}
void GuiFrame::remove(GuiElement* e) {
void GuiFrame::remove(GuiElement *e) {
if (e == NULL)
return;
for (uint32_t i = 0; i < elements.size(); ++i) {
if(e == elements[i]) {
elements.erase(elements.begin()+i);
if (e == elements[i]) {
elements.erase(elements.begin() + i);
break;
}
}
@ -85,7 +85,7 @@ void GuiFrame::dimBackground(bool d) {
dim = d;
}
GuiElement* GuiFrame::getGuiElementAt(uint32_t index) const {
GuiElement *GuiFrame::getGuiElementAt(uint32_t index) const {
if (index >= elements.size())
return NULL;
return elements[index];
@ -131,7 +131,7 @@ int32_t GuiFrame::getSelected() {
// find selected element
int32_t found = -1;
for (uint32_t i = 0; i < elements.size(); ++i) {
if(elements[i]->isStateSet(STATE_SELECTED | STATE_OVER)) {
if (elements[i]->isStateSet(STATE_SELECTED | STATE_OVER)) {
found = i;
break;
}
@ -139,11 +139,11 @@ int32_t GuiFrame::getSelected() {
return found;
}
void GuiFrame::draw(CVideo * v) {
if(!this->isVisible() && parentElement)
void GuiFrame::draw(CVideo *v) {
if (!this->isVisible() && parentElement)
return;
if(parentElement && dim == true) {
if (parentElement && dim == true) {
//GXColor dimColor = (GXColor){0, 0, 0, 0x70};
//Menu_DrawRectangle(0, 0, GetZPosition(), screenwidth,screenheight, &dimColor, false, true);
}
@ -157,7 +157,7 @@ void GuiFrame::draw(CVideo * v) {
}
void GuiFrame::updateEffects() {
if(!this->isVisible() && parentElement)
if (!this->isVisible() && parentElement)
return;
GuiElement::updateEffects();
@ -171,7 +171,7 @@ void GuiFrame::updateEffects() {
}
void GuiFrame::process() {
if(!this->isVisible() && parentElement)
if (!this->isVisible() && parentElement)
return;
GuiElement::process();
@ -184,8 +184,8 @@ void GuiFrame::process() {
}
}
void GuiFrame::update(GuiController * c) {
if(isStateSet(STATE_DISABLED) && parentElement)
void GuiFrame::update(GuiController *c) {
if (isStateSet(STATE_DISABLED) && parentElement)
return;
//! update appended items next frame

68
source/gui/GuiImage.cpp
View File

@ -20,10 +20,10 @@
#include <gui/video/shaders/ColorShader.h>
#include "utils/utils.h"
static const float fPiDiv180 = ((float)M_PI / 180.0f);
static const float fPiDiv180 = ((float) M_PI / 180.0f);
GuiImage::GuiImage(GuiImageData * img) {
if(img && img->getTexture()) {
GuiImage::GuiImage(GuiImageData *img) {
if (img && img->getTexture()) {
width = img->getWidth();
height = img->getHeight();
}
@ -32,14 +32,14 @@ GuiImage::GuiImage(GuiImageData * img) {
imageData = img;
}
GuiImage::GuiImage(int32_t w, int32_t h, const GX2Color & c, int32_t type) {
GuiImage::GuiImage(int32_t w, int32_t h, const GX2Color &c, int32_t type) {
internalInit(w, h);
imgType = type;
colorCount = ColorShader::cuColorVtxsSize / ColorShader::cuColorAttrSize;
colorVtxs = (uint8_t *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, colorCount * ColorShader::cuColorAttrSize);
if(colorVtxs) {
for(uint32_t i = 0; i < colorCount; i++)
if (colorVtxs) {
for (uint32_t i = 0; i < colorCount; i++)
setImageColor(c, i);
}
}
@ -48,12 +48,12 @@ GuiImage::GuiImage(int32_t w, int32_t h, const GX2Color *c, uint32_t color_count
internalInit(w, h);
imgType = type;
colorCount = ColorShader::cuColorVtxsSize / ColorShader::cuColorAttrSize;
if(colorCount < color_count)
if (colorCount < color_count)
colorCount = color_count;
colorVtxs = (uint8_t *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, colorCount * ColorShader::cuColorAttrSize);
if(colorVtxs) {
for(uint32_t i = 0; i < colorCount; i++) {
if (colorVtxs) {
for (uint32_t i = 0; i < colorCount; i++) {
// take the last as reference if not enough colors defined
int32_t idx = (i < color_count) ? i : (color_count - 1);
setImageColor(c[idx], i);
@ -65,7 +65,7 @@ GuiImage::GuiImage(int32_t w, int32_t h, const GX2Color *c, uint32_t color_count
* Destructor for the GuiImage class.
*/
GuiImage::~GuiImage() {
if(colorVtxs) {
if (colorVtxs) {
free(colorVtxs);
colorVtxs = NULL;
}
@ -93,11 +93,11 @@ void GuiImage::internalInit(int32_t w, int32_t h) {
colorIntensity = glm::vec4(1.0f);
}
void GuiImage::setImageData(GuiImageData * img) {
void GuiImage::setImageData(GuiImageData *img) {
imageData = img;
width = 0;
height = 0;
if(img && img->getTexture()) {
if (img && img->getTexture()) {
width = img->getWidth();
height = img->getHeight();
}
@ -105,46 +105,46 @@ void GuiImage::setImageData(GuiImageData * img) {
}
GX2Color GuiImage::getPixel(int32_t x, int32_t y) {
if(!imageData || this->getWidth() <= 0 || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight())
if (!imageData || this->getWidth() <= 0 || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight())
return (GX2Color) {
0, 0, 0, 0
};
0, 0, 0, 0
};
uint32_t pitch = imageData->getTexture()->surface.pitch;
uint32_t *imagePtr = (uint32_t*)imageData->getTexture()->surface.image;
uint32_t *imagePtr = (uint32_t *) imageData->getTexture()->surface.image;
uint32_t color_u32 = imagePtr[y * pitch + x];
GX2Color color;
color.r = (color_u32 >> 24) & 0xFF;
color.g = (color_u32 >> 16) & 0xFF;
color.b = (color_u32 >> 8) & 0xFF;
color.a = (color_u32 >> 0) & 0xFF;
color.b = (color_u32 >> 8) & 0xFF;
color.a = (color_u32 >> 0) & 0xFF;
return color;
}
void GuiImage::setPixel(int32_t x, int32_t y, const GX2Color & color) {
if(!imageData || this->getWidth() <= 0 || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight())
void GuiImage::setPixel(int32_t x, int32_t y, const GX2Color &color) {
if (!imageData || this->getWidth() <= 0 || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight())
return;
uint32_t pitch = imageData->getTexture()->surface.pitch;
uint32_t *imagePtr = (uint32_t*)imageData->getTexture()->surface.image;
imagePtr[y * pitch + x] = (color.r << 24) | (color.g << 16) | (color.b << 8) | (color.a << 0);
uint32_t *imagePtr = (uint32_t *) imageData->getTexture()->surface.image;
imagePtr[y * pitch + x] = (color.r << 24) | (color.g << 16) | (color.b << 8) | (color.a << 0);
}
void GuiImage::setImageColor(const GX2Color & c, int32_t idx) {
if(!colorVtxs) {
void GuiImage::setImageColor(const GX2Color &c, int32_t idx) {
if (!colorVtxs) {
return;
}
if(idx >= 0 && idx < (int32_t)colorCount) {
if (idx >= 0 && idx < (int32_t) colorCount) {
colorVtxs[(idx << 2) + 0] = c.r;
colorVtxs[(idx << 2) + 1] = c.g;
colorVtxs[(idx << 2) + 2] = c.b;
colorVtxs[(idx << 2) + 3] = c.a;
colorVtxsDirty = true;
} else if(colorVtxs) {
for(uint32_t i = 0; i < (ColorShader::cuColorVtxsSize / sizeof(uint8_t)); i += 4) {
} else if (colorVtxs) {
for (uint32_t i = 0; i < (ColorShader::cuColorVtxsSize / sizeof(uint8_t)); i += 4) {
colorVtxs[i + 0] = c.r;
colorVtxs[i + 1] = c.g;
colorVtxs[i + 2] = c.b;
@ -165,10 +165,10 @@ void GuiImage::setPrimitiveVertex(int32_t prim, const float *posVtx, const float
posVtxs = posVtx;
texCoords = texCoord;
if(imgType == IMAGE_COLOR) {
uint8_t * newColorVtxs = (uint8_t *) memalign(0x40, ColorShader::cuColorAttrSize * vtxCount);
if (imgType == IMAGE_COLOR) {
uint8_t *newColorVtxs = (uint8_t *) memalign(0x40, ColorShader::cuColorAttrSize * vtxCount);
for(uint32_t i = 0; i < vtxCount; i++) {
for (uint32_t i = 0; i < vtxCount; i++) {
int32_t newColorIdx = (i << 2);
int32_t colorIdx = (i < colorCount) ? (newColorIdx) : ((colorCount - 1) << 2);
@ -186,7 +186,7 @@ void GuiImage::setPrimitiveVertex(int32_t prim, const float *posVtx, const float
}
void GuiImage::draw(CVideo *pVideo) {
if(!this->isVisible() || tileVertical == 0 || tileHorizontal == 0)
if (!this->isVisible() || tileVertical == 0 || tileHorizontal == 0)
return;
float currScaleX = getScaleX();
@ -238,13 +238,13 @@ void GuiImage::draw(CVideo *pVideo) {
// Menu_DrawImgCut(image, width, height, format, currLeft, currTop+height*i, currZ, imageangle, currScaleX, currScaleY, currAlpha, cutBoundsRect.x1(), cutBoundsRect.x2(), cutBoundsRect.y1(), cutBoundsRect.y2());
// }
// }
if(colorVtxsDirty && colorVtxs) {
if (colorVtxsDirty && colorVtxs) {
//! flush color vertex only on main GX2 thread
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, colorVtxs, colorCount * ColorShader::cuColorAttrSize);
colorVtxsDirty = false;
}
if(imgType == IMAGE_COLOR && colorVtxs) {
if (imgType == IMAGE_COLOR && colorVtxs) {
ColorShader::instance()->setShaders();
ColorShader::instance()->setAttributeBuffer(colorVtxs, posVtxs, vtxCount);
ColorShader::instance()->setAngle(imageAngle);
@ -252,7 +252,7 @@ void GuiImage::draw(CVideo *pVideo) {
ColorShader::instance()->setScale(scaleFactor);
ColorShader::instance()->setColorIntensity(colorIntensity);
ColorShader::instance()->draw(primitive, vtxCount);
} else if(imageData) {
} else if (imageData) {
Texture2DShader::instance()->setShaders();
Texture2DShader::instance()->setAttributeBuffer(texCoords, posVtxs, vtxCount);
Texture2DShader::instance()->setAngle(imageAngle);

57
source/gui/GuiImageAsync.cpp
View File

@ -19,34 +19,27 @@
#include "../fs/CFile.hpp"
std::vector<GuiImageAsync *> GuiImageAsync::imageQueue;
CThread * GuiImageAsync::pThread = NULL;
std::recursive_mutex * GuiImageAsync::pMutex = NULL;
CThread *GuiImageAsync::pThread = NULL;
std::recursive_mutex *GuiImageAsync::pMutex = NULL;
uint32_t GuiImageAsync::threadRefCounter = 0;
bool GuiImageAsync::bExitRequested = false;
GuiImageAsync * GuiImageAsync::pInUse = NULL;
GuiImageAsync *GuiImageAsync::pInUse = NULL;
GuiImageAsync::GuiImageAsync(const uint8_t *imageBuffer, const uint32_t & imageBufferSize, GuiImageData * preloadImg)
: GuiImage(preloadImg)
, imgData(NULL)
, imgBuffer(imageBuffer)
, imgBufferSize(imageBufferSize) {
GuiImageAsync::GuiImageAsync(const uint8_t *imageBuffer, const uint32_t &imageBufferSize, GuiImageData *preloadImg)
: GuiImage(preloadImg), imgData(NULL), imgBuffer(imageBuffer), imgBufferSize(imageBufferSize) {
threadInit();
threadAddImage(this);
}
GuiImageAsync::GuiImageAsync(const std::string & file, GuiImageData * preloadImg)
: GuiImage(preloadImg)
, imgData(NULL)
, filename(file)
, imgBuffer(NULL)
, imgBufferSize(0) {
GuiImageAsync::GuiImageAsync(const std::string &file, GuiImageData *preloadImg)
: GuiImage(preloadImg), imgData(NULL), filename(file), imgBuffer(NULL), imgBufferSize(0) {
threadInit();
threadAddImage(this);
}
GuiImageAsync::~GuiImageAsync() {
threadRemoveImage(this);
while(pInUse == this)
while (pInUse == this)
OSSleepTicks(OSMicrosecondsToTicks(1000));
if (imgData)
@ -64,8 +57,8 @@ void GuiImageAsync::threadAddImage(GuiImageAsync *Image) {
void GuiImageAsync::threadRemoveImage(GuiImageAsync *image) {
pMutex->lock();
for(uint32_t i = 0; i < imageQueue.size(); ++i) {
if(imageQueue[i] == image) {
for (uint32_t i = 0; i < imageQueue.size(); ++i) {
if (imageQueue[i] == image) {
imageQueue.erase(imageQueue.begin() + i);
break;
}
@ -80,11 +73,11 @@ void GuiImageAsync::clearQueue() {
}
void GuiImageAsync::guiImageAsyncThread(CThread *thread, void *arg) {
while(!bExitRequested) {
if(imageQueue.empty() && !bExitRequested)
while (!bExitRequested) {
if (imageQueue.empty() && !bExitRequested)
pThread->suspendThread();
if(!imageQueue.empty() && !bExitRequested) {
if (!imageQueue.empty() && !bExitRequested) {
pMutex->lock();
pInUse = imageQueue.front();
imageQueue.erase(imageQueue.begin());
@ -94,39 +87,39 @@ void GuiImageAsync::guiImageAsyncThread(CThread *thread, void *arg) {
continue;
if(pInUse->imgBuffer && pInUse->imgBufferSize) {
if (pInUse->imgBuffer && pInUse->imgBufferSize) {
pInUse->imgData = new GuiImageData(pInUse->imgBuffer, pInUse->imgBufferSize);
} else {
uint8_t *buffer = NULL;
uint64_t bufferSize = 0;
CFile file(pInUse->filename, CFile::ReadOnly);
if(file.isOpen()) {
if (file.isOpen()) {
uint64_t filesize = file.size();
buffer = (uint8_t *) malloc(filesize);
if (buffer != NULL) {
uint32_t blocksize = 0x4000;
uint32_t done = 0;
int32_t readBytes = 0;
while(done < filesize) {
if(done + blocksize > filesize) {
while (done < filesize) {
if (done + blocksize > filesize) {
blocksize = filesize - done;
}
readBytes = file.read(buffer + done, blocksize);
if(readBytes <= 0)
if (readBytes <= 0)
break;
done += readBytes;
}
if(done == filesize){
if (done == filesize) {
bufferSize = filesize;
}else{
} else {
free(buffer);
}
}
file.close();
}
if(buffer != NULL && bufferSize > 0) {
if (buffer != NULL && bufferSize > 0) {
pInUse->imgData = new GuiImageData(buffer, bufferSize, GX2_TEX_CLAMP_MODE_MIRROR);
//! free original image buffer which is converted to texture now and not needed anymore
@ -134,8 +127,8 @@ void GuiImageAsync::guiImageAsyncThread(CThread *thread, void *arg) {
}
}
if(pInUse->imgData) {
if(pInUse->imgData->getTexture()) {
if (pInUse->imgData) {
if (pInUse->imgData->getTexture()) {
pInUse->width = pInUse->imgData->getWidth();
pInUse->height = pInUse->imgData->getHeight();
pInUse->imageData = pInUse->imgData;
@ -162,11 +155,11 @@ void GuiImageAsync::threadInit() {
}
void GuiImageAsync::threadExit() {
if(threadRefCounter) {
if (threadRefCounter) {
--threadRefCounter;
}
if(/*(threadRefCounter == 0) &&*/ (pThread != NULL)) {
if (/*(threadRefCounter == 0) &&*/ (pThread != NULL)) {
bExitRequested = true;
delete pThread;
delete pMutex;

85
source/gui/GuiImageData.cpp
View File

@ -19,6 +19,7 @@
#include <stdint.h>
#include <gui/GuiImageData.h>
#include <gui/memory.h>
/**
* Constructor for the GuiImageData class.
*/
@ -31,7 +32,7 @@ GuiImageData::GuiImageData() {
/**
* Constructor for the GuiImageData class.
*/
GuiImageData::GuiImageData(const uint8_t * img, int32_t imgSize, GX2TexClampMode textureClamp, GX2SurfaceFormat textureFormat) {
GuiImageData::GuiImageData(const uint8_t *img, int32_t imgSize, GX2TexClampMode textureClamp, GX2SurfaceFormat textureFormat) {
texture = NULL;
sampler = NULL;
loadImage(img, imgSize, textureClamp, textureFormat);
@ -45,32 +46,32 @@ GuiImageData::~GuiImageData() {
}
void GuiImageData::releaseData(void) {
if(texture) {
if(texture->surface.image) {
switch(memoryType) {
default:
case eMemTypeMEM2:
free(texture->surface.image);
break;
case eMemTypeMEM1:
MEM1_free(texture->surface.image);
break;
case eMemTypeMEMBucket:
MEMBucket_free(texture->surface.image);
break;
if (texture) {
if (texture->surface.image) {
switch (memoryType) {
default:
case eMemTypeMEM2:
free(texture->surface.image);
break;
case eMemTypeMEM1:
MEM1_free(texture->surface.image);
break;
case eMemTypeMEMBucket:
MEMBucket_free(texture->surface.image);
break;
}
}
delete texture;
texture = NULL;
}
if(sampler) {
if (sampler) {
delete sampler;
sampler = NULL;
}
}
void GuiImageData::loadImage(const uint8_t *img, int32_t imgSize, GX2TexClampMode textureClamp, GX2SurfaceFormat textureFormat) {
if(!img || (imgSize < 8))
if (!img || (imgSize < 8))
return;
releaseData();
@ -80,21 +81,21 @@ void GuiImageData::loadImage(const uint8_t *img, int32_t imgSize, GX2TexClampMod
//! not needed for now therefore comment out to safe ELF size
//! if needed uncomment, adds 200 kb to the ELF size
// IMAGE_JPEG
gdImg = gdImageCreateFromJpegPtr(imgSize, (uint8_t*) img);
gdImg = gdImageCreateFromJpegPtr(imgSize, (uint8_t *) img);
} else if (img[0] == 'B' && img[1] == 'M') {
// IMAGE_BMP
gdImg = gdImageCreateFromBmpPtr(imgSize, (uint8_t*) img);
gdImg = gdImageCreateFromBmpPtr(imgSize, (uint8_t *) img);
} else if (img[0] == 0x89 && img[1] == 'P' && img[2] == 'N' && img[3] == 'G') {
// IMAGE_PNG
gdImg = gdImageCreateFromPngPtr(imgSize, (uint8_t*) img);
gdImg = gdImageCreateFromPngPtr(imgSize, (uint8_t *) img);
}
//!This must be last since it can also intefere with outher formats
else if(img[0] == 0x00) {
//!This must be last since it can also intefere with outher formats
else if (img[0] == 0x00) {
// Try loading TGA image
gdImg = gdImageCreateFromTgaPtr(imgSize, (uint8_t*) img);
gdImg = gdImageCreateFromTgaPtr(imgSize, (uint8_t *) img);
}
if(gdImg == 0)
if (gdImg == 0)
return;
uint32_t width = (gdImageSX(gdImg));
@ -102,10 +103,10 @@ void GuiImageData::loadImage(const uint8_t *img, int32_t imgSize, GX2TexClampMod
//! Initialize texture
texture = new GX2Texture;
GX2InitTexture(texture, width, height, 1, 0, textureFormat, GX2_SURFACE_DIM_TEXTURE_2D, GX2_TILE_MODE_LINEAR_ALIGNED);
GX2InitTexture(texture, width, height, 1, 0, textureFormat, GX2_SURFACE_DIM_TEXTURE_2D, GX2_TILE_MODE_LINEAR_ALIGNED);
//! if this fails something went horribly wrong
if(texture->surface.imageSize == 0) {
if (texture->surface.imageSize == 0) {
delete texture;
texture = NULL;
gdImageDestroy(gdImg);
@ -116,17 +117,17 @@ void GuiImageData::loadImage(const uint8_t *img, int32_t imgSize, GX2TexClampMod
memoryType = eMemTypeMEM2;
texture->surface.image = memalign(texture->surface.alignment, texture->surface.imageSize);
//! try MEM1 on failure
if(!texture->surface.image) {
if (!texture->surface.image) {
memoryType = eMemTypeMEM1;
texture->surface.image = MEM1_alloc(texture->surface.imageSize, texture->surface.alignment);
}
//! try MEM bucket on failure
if(!texture->surface.image) {
if (!texture->surface.image) {
memoryType = eMemTypeMEMBucket;
texture->surface.image = MEMBucket_alloc(texture->surface.imageSize, texture->surface.alignment);
}
//! check if memory is available for image
if(!texture->surface.image) {
if (!texture->surface.image) {
gdImageDestroy(gdImg);
delete texture;
texture = NULL;
@ -135,14 +136,14 @@ void GuiImageData::loadImage(const uint8_t *img, int32_t imgSize, GX2TexClampMod
//! set mip map data pointer
texture->surface.mipmaps = NULL;
//! convert image to texture
switch(textureFormat) {
default:
case GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8:
gdImageToUnormR8G8B8A8(gdImg, (uint32_t*)texture->surface.image, texture->surface.width, texture->surface.height, texture->surface.pitch);
break;
case GX2_SURFACE_FORMAT_UNORM_R5_G6_B5:
gdImageToUnormR5G6B5(gdImg, (uint16_t*)texture->surface.image, texture->surface.width, texture->surface.height, texture->surface.pitch);
break;
switch (textureFormat) {
default:
case GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8:
gdImageToUnormR8G8B8A8(gdImg, (uint32_t *) texture->surface.image, texture->surface.width, texture->surface.height, texture->surface.pitch);
break;
case GX2_SURFACE_FORMAT_UNORM_R5_G6_B5:
gdImageToUnormR5G6B5(gdImg, (uint16_t *) texture->surface.image, texture->surface.width, texture->surface.height, texture->surface.pitch);
break;
}
//! free memory of image as its not needed anymore
@ -156,12 +157,12 @@ void GuiImageData::loadImage(const uint8_t *img, int32_t imgSize, GX2TexClampMod
}
void GuiImageData::gdImageToUnormR8G8B8A8(gdImagePtr gdImg, uint32_t *imgBuffer, uint32_t width, uint32_t height, uint32_t pitch) {
for(uint32_t y = 0; y < height; ++y) {
for(uint32_t x = 0; x < width; ++x) {
for (uint32_t y = 0; y < height; ++y) {
for (uint32_t x = 0; x < width; ++x) {
uint32_t pixel = gdImageGetPixel(gdImg, x, y);
uint8_t a = 254 - 2*((uint8_t)gdImageAlpha(gdImg, pixel));
if(a == 254) a++;
uint8_t a = 254 - 2 * ((uint8_t) gdImageAlpha(gdImg, pixel));
if (a == 254) a++;
uint8_t r = gdImageRed(gdImg, pixel);
uint8_t g = gdImageGreen(gdImg, pixel);
@ -174,8 +175,8 @@ void GuiImageData::gdImageToUnormR8G8B8A8(gdImagePtr gdImg, uint32_t *imgBuffer,
//! TODO: figure out why this seems to not work correct yet
void GuiImageData::gdImageToUnormR5G6B5(gdImagePtr gdImg, uint16_t *imgBuffer, uint32_t width, uint32_t height, uint32_t pitch) {
for(uint32_t y = 0; y < height; ++y) {
for(uint32_t x = 0; x < width; ++x) {
for (uint32_t y = 0; y < height; ++y) {
for (uint32_t x = 0; x < width; ++x) {
uint32_t pixel = gdImageGetPixel(gdImg, x, y);
uint8_t r = gdImageRed(gdImg, pixel);

14
source/gui/GuiParticleImage.cpp
View File

@ -30,7 +30,7 @@ static inline float getRandMinusOneToOneF32() {
}
GuiParticleImage::GuiParticleImage(int32_t w, int32_t h, uint32_t particleCount, float minRadius, float maxRadius, float minSpeed, float maxSpeed)
: GuiImage(NULL) {
: GuiImage(NULL) {
width = w;
height = h;
imgType = IMAGE_COLOR;
@ -42,7 +42,7 @@ GuiParticleImage::GuiParticleImage(int32_t w, int32_t h, uint32_t particleCount,
posVertexs = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ColorShader::cuVertexAttrSize * CIRCLE_VERTEX_COUNT);
colorVertexs = (uint8_t *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ColorShader::cuColorAttrSize * CIRCLE_VERTEX_COUNT);
for(uint32_t i = 0; i < CIRCLE_VERTEX_COUNT; i++) {
for (uint32_t i = 0; i < CIRCLE_VERTEX_COUNT; i++) {
posVertexs[i * 3 + 0] = cosf(DegToRad(i * 360.0f / CIRCLE_VERTEX_COUNT));
posVertexs[i * 3 + 1] = sinf(DegToRad(i * 360.0f / CIRCLE_VERTEX_COUNT));
posVertexs[i * 3 + 2] = 0.0f;
@ -57,7 +57,7 @@ GuiParticleImage::GuiParticleImage(int32_t w, int32_t h, uint32_t particleCount,
particles.resize(particleCount);
for(uint32_t i = 0; i < particleCount; i++) {
for (uint32_t i = 0; i < particleCount; i++) {
particles[i].position.x = getRandMinusOneToOneF32() * getWidth() * 0.5f;
particles[i].position.y = getRandMinusOneToOneF32() * getHeight() * 0.5f;
particles[i].position.z = 0.0f;
@ -74,7 +74,7 @@ GuiParticleImage::~GuiParticleImage() {
}
void GuiParticleImage::draw(CVideo *pVideo) {
if(!this->isVisible())
if (!this->isVisible())
return;
@ -88,8 +88,8 @@ void GuiParticleImage::draw(CVideo *pVideo) {
//! add other colors intensities parameters
colorIntensity[3] = getAlpha();
for(uint32_t i = 0; i < particles.size(); ++i) {
if(particles[i].position.y > (getHeight() * 0.5f + 30.0f)) {
for (uint32_t i = 0; i < particles.size(); ++i) {
if (particles[i].position.y > (getHeight() * 0.5f + 30.0f)) {
particles[i].position.x = getRandMinusOneToOneF32() * getWidth() * 0.5f;
particles[i].position.y = -getHeight() * 0.5f - 30.0f;
particles[i].colors = glm::vec4(1.0f, 1.0f, 1.0f, (getRandZeroToOneF32() * 0.6f) + 0.05f);
@ -97,7 +97,7 @@ void GuiParticleImage::draw(CVideo *pVideo) {
particles[i].speed = (getRandZeroToOneF32() * (maxSpeed - minSpeed)) + minSpeed;
particles[i].direction = getRandMinusOneToOneF32();
}
if(particles[i].position.x < (-getWidth() * 0.5f - 50.0f)) {
if (particles[i].position.x < (-getWidth() * 0.5f - 50.0f)) {
particles[i].position.x = -particles[i].position.x;
}

65
source/gui/GuiScrollbar.cpp
View File

@ -25,8 +25,7 @@
#include "utils/utils.h"
GuiScrollbar::GuiScrollbar(int32_t h)
: touchTrigger(GuiTrigger::CHANNEL_1, GuiTrigger::VPAD_TOUCH)
, wpadTouchTrigger(GuiTrigger::CHANNEL_2 | GuiTrigger::CHANNEL_3 | GuiTrigger::CHANNEL_4 | GuiTrigger::CHANNEL_5, GuiTrigger::BUTTON_A) {
: touchTrigger(GuiTrigger::CHANNEL_1, GuiTrigger::VPAD_TOUCH), wpadTouchTrigger(GuiTrigger::CHANNEL_2 | GuiTrigger::CHANNEL_3 | GuiTrigger::CHANNEL_4 | GuiTrigger::CHANNEL_5, GuiTrigger::BUTTON_A) {
SelItem = 0;
SelInd = 0;
PageSize = 0;
@ -74,17 +73,17 @@ GuiScrollbar::~GuiScrollbar() {
}
void GuiScrollbar::ScrollOneUp() {
if(SelItem == 0 && SelInd > 0) {
if (SelItem == 0 && SelInd > 0) {
// move list up by 1
--SelInd;
} else if(SelInd+SelItem > 0) {
} else if (SelInd + SelItem > 0) {
--SelItem;
}
}
void GuiScrollbar::ScrollOneDown() {
if(SelInd+SelItem + 1 < EntrieCount) {
if(SelItem == PageSize-1) {
if (SelInd + SelItem + 1 < EntrieCount) {
if (SelItem == PageSize - 1) {
// move list down by 1
SelInd++;
} else {
@ -94,7 +93,7 @@ void GuiScrollbar::ScrollOneDown() {
}
void GuiScrollbar::OnUpButtonClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger) {
if(ScrollState < ScrollSpeed)
if (ScrollState < ScrollSpeed)
return;
ScrollOneUp();
@ -104,7 +103,7 @@ void GuiScrollbar::OnUpButtonClick(GuiButton *button, const GuiController *contr
}
void GuiScrollbar::OnDownButtonClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger) {
if(ScrollState < ScrollSpeed)
if (ScrollState < ScrollSpeed)
return;
ScrollOneDown();
@ -114,11 +113,11 @@ void GuiScrollbar::OnDownButtonClick(GuiButton *button, const GuiController *con
}
void GuiScrollbar::OnBoxButtonHold(GuiButton *button, const GuiController *controller, GuiTrigger *trigger) {
if(EntrieCount == 0) {
if (EntrieCount == 0) {
return;
}
if(!controller->data.validPointer) {
if (!controller->data.validPointer) {
return;
}
@ -126,22 +125,22 @@ void GuiScrollbar::OnBoxButtonHold(GuiButton *button, const GuiController *contr
int32_t positionWiimote = LIMIT(y - MinHeight, 0, MaxHeight - MinHeight);
int32_t newSelected = (EntrieCount - 1) - (int32_t) ((float) positionWiimote / (float) (MaxHeight-MinHeight) * (float) (EntrieCount-1));
int32_t newSelected = (EntrieCount - 1) - (int32_t) ((float) positionWiimote / (float) (MaxHeight - MinHeight) * (float) (EntrieCount - 1));
int32_t diff = newSelected-SelInd-SelItem;
int32_t diff = newSelected - SelInd - SelItem;
if(newSelected <= 0) {
if (newSelected <= 0) {
SelItem = 0;
SelInd = 0;
} else if(newSelected >= EntrieCount-1) {
SelItem = (PageSize-1 < EntrieCount-1) ? PageSize-1 : EntrieCount-1;
SelInd = EntrieCount-PageSize;
} else if(newSelected < PageSize && SelInd == 0 && diff < 0) {
SelItem = std::max(SelItem+diff, (int32_t)0);
} else if(EntrieCount-newSelected < PageSize && SelInd == EntrieCount-PageSize && diff > 0) {
SelItem = std::min(SelItem+diff, PageSize-1);
} else if (newSelected >= EntrieCount - 1) {
SelItem = (PageSize - 1 < EntrieCount - 1) ? PageSize - 1 : EntrieCount - 1;
SelInd = EntrieCount - PageSize;
} else if (newSelected < PageSize && SelInd == 0 && diff < 0) {
SelItem = std::max(SelItem + diff, (int32_t) 0);
} else if (EntrieCount - newSelected < PageSize && SelInd == EntrieCount - PageSize && diff > 0) {
SelItem = std::min(SelItem + diff, PageSize - 1);
} else {
SelInd = LIMIT(SelInd+diff, 0, ((EntrieCount-PageSize < 0) ? 0 : EntrieCount-PageSize));
SelInd = LIMIT(SelInd + diff, 0, ((EntrieCount - PageSize < 0) ? 0 : EntrieCount - PageSize));
}
ScrollState = 0;
@ -149,7 +148,7 @@ void GuiScrollbar::OnBoxButtonHold(GuiButton *button, const GuiController *contr
}
void GuiScrollbar::SetPageSize(int32_t size) {
if(PageSize == size)
if (PageSize == size)
return;
PageSize = size;
@ -157,15 +156,15 @@ void GuiScrollbar::SetPageSize(int32_t size) {
}
void GuiScrollbar::SetSelectedItem(int32_t pos) {
if(SelItem == pos)
if (SelItem == pos)
return;
SelItem = LIMIT(pos, 0, EntrieCount-1);
SelItem = LIMIT(pos, 0, EntrieCount - 1);
listChanged(SelItem, SelInd);
}
void GuiScrollbar::SetSelectedIndex(int32_t pos) {
if(SelInd == pos)
if (SelInd == pos)
return;
SelInd = pos;
@ -173,7 +172,7 @@ void GuiScrollbar::SetSelectedIndex(int32_t pos) {
}
void GuiScrollbar::SetEntrieCount(int32_t cnt) {
if(EntrieCount == cnt)
if (EntrieCount == cnt)
return;
EntrieCount = cnt;
@ -181,18 +180,18 @@ void GuiScrollbar::SetEntrieCount(int32_t cnt) {
}
void GuiScrollbar::setScrollboxPosition(int32_t SelItem, int32_t SelInd) {
int32_t position = MaxHeight-(MaxHeight-MinHeight)*(SelInd+SelItem)/(EntrieCount-1);
int32_t position = MaxHeight - (MaxHeight - MinHeight) * (SelInd + SelItem) / (EntrieCount - 1);
if(position < MinHeight || (SelInd+SelItem >= EntrieCount-1))
if (position < MinHeight || (SelInd + SelItem >= EntrieCount - 1))
position = MinHeight;
else if(position > MaxHeight || (SelInd+SelItem) == 0)
else if (position > MaxHeight || (SelInd + SelItem) == 0)
position = MaxHeight;
scrollbarBoxBtn->setPosition(0, position);
}
void GuiScrollbar::draw(CVideo * video) {
if(scrollbarLineImage) {
void GuiScrollbar::draw(CVideo *video) {
if (scrollbarLineImage) {
scrollbarLineImage->draw(video);
}
arrowUpBtn->draw(video);
@ -202,8 +201,8 @@ void GuiScrollbar::draw(CVideo * video) {
updateEffects();
}
void GuiScrollbar::update(GuiController * t) {
if(this->isStateSet(STATE_DISABLED))
void GuiScrollbar::update(GuiController *t) {
if (this->isStateSet(STATE_DISABLED))
return;
arrowUpBtn->update(t);

97
source/gui/GuiSelectBox.cpp
View File

@ -26,18 +26,11 @@
* Constructor for the GuiCheckBox class.
*/
GuiSelectBox::GuiSelectBox(GuiImage * background,std::string caption,float width,float height,GuiFrame *parent)
: GuiFrame(width,height,parent)
,selected(0)
,captionText(caption)
,topValueButton(0,0)
,touchTrigger(GuiTrigger::CHANNEL_1, GuiTrigger::VPAD_TOUCH)
,wpadTouchTrigger(GuiTrigger::CHANNEL_2 | GuiTrigger::CHANNEL_3 | GuiTrigger::CHANNEL_4 | GuiTrigger::CHANNEL_5, GuiTrigger::BUTTON_A)
,buttonATrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_A, true)
,buttonBTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_B, true)
,buttonUpTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_UP | GuiTrigger::STICK_L_UP, true)
,buttonDownTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_DOWN | GuiTrigger::STICK_L_DOWN, true)
,DPADButtons(0,0) {
GuiSelectBox::GuiSelectBox(GuiImage *background, std::string caption, float width, float height, GuiFrame *parent)
: GuiFrame(width, height, parent), selected(0), captionText(caption), topValueButton(0, 0), touchTrigger(GuiTrigger::CHANNEL_1, GuiTrigger::VPAD_TOUCH),
wpadTouchTrigger(GuiTrigger::CHANNEL_2 | GuiTrigger::CHANNEL_3 | GuiTrigger::CHANNEL_4 | GuiTrigger::CHANNEL_5, GuiTrigger::BUTTON_A), buttonATrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_A, true),
buttonBTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_B, true), buttonUpTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_UP | GuiTrigger::STICK_L_UP, true),
buttonDownTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_DOWN | GuiTrigger::STICK_L_DOWN, true), DPADButtons(0, 0) {
setImageTopBackground(background);
showValues = false;
bChanged = false;
@ -45,7 +38,7 @@ GuiSelectBox::GuiSelectBox(GuiImage * background,std::string caption,float width
opened = false;
topValueText.setFontSize(32);
topValueText.setAlignment(ALIGN_LEFT);
topValueText.setPosition(10,-7);
topValueText.setPosition(10, -7);
topValueButton.setLabel(&topValueText);
topValueButton.setTrigger(&touchTrigger);
topValueButton.setTrigger(&wpadTouchTrigger);
@ -68,14 +61,14 @@ GuiSelectBox::GuiSelectBox(GuiImage * background,std::string caption,float width
bChanged = true;
}
void GuiSelectBox::setSize(float width,float height) {
GuiFrame::setSize(width,height);
topValueButton.setSize(width,height);
void GuiSelectBox::setSize(float width, float height) {
GuiFrame::setSize(width, height);
topValueButton.setSize(width, height);
}
void GuiSelectBox::OnValueClicked(GuiButton *button, const GuiController *controller, GuiTrigger *trigger) {
for(uint32_t i = 0; i < valueButtons.size(); ++i) {
if(valueButtons[i].valueButton == button) {
for (uint32_t i = 0; i < valueButtons.size(); ++i) {
if (valueButtons[i].valueButton == button) {
selected = i;
SelectValue(i);
break;
@ -84,16 +77,16 @@ void GuiSelectBox::OnValueClicked(GuiButton *button, const GuiController *contro
}
void GuiSelectBox::SelectValue(uint32_t value) {
if(value < valueButtons.size()) {
const wchar_t* w_text = valueButtons[value].valueButtonText->getText();
if (value < valueButtons.size()) {
const wchar_t *w_text = valueButtons[value].valueButtonText->getText();
std::wstring ws(w_text);
std::string text(ws.begin(), ws.end());
topValueText.setText(text.c_str());
std::string real_value = buttonToValue[valueButtons[value].valueButton];
if(real_value.compare(std::string()) == 0) real_value = "<error>";
if (real_value.compare(std::string()) == 0) real_value = "<error>";
valueChanged(this,real_value);
valueChanged(this, real_value);
ShowHideValues(false);
}
}
@ -108,31 +101,31 @@ void GuiSelectBox::ShowHideValues(bool showhide) {
}
void GuiSelectBox::OnDPADClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger) {
if(opened == true) {
if(trigger == &buttonATrigger) {
if (opened == true) {
if (trigger == &buttonATrigger) {
//! do not auto launch when wiimote is pointing to screen and presses A
if((controller->chan & (GuiTrigger::CHANNEL_2 | GuiTrigger::CHANNEL_3 | GuiTrigger::CHANNEL_4 | GuiTrigger::CHANNEL_5)) && controller->data.validPointer) {
if ((controller->chan & (GuiTrigger::CHANNEL_2 | GuiTrigger::CHANNEL_3 | GuiTrigger::CHANNEL_4 | GuiTrigger::CHANNEL_5)) && controller->data.validPointer) {
return;
}
SelectValue(selected);
} else if(trigger == &buttonBTrigger) {
if(button == &DPADButtons) {
} else if (trigger == &buttonBTrigger) {
if (button == &DPADButtons) {
ShowHideValues(false);
} else {
}
} else if(trigger == &buttonUpTrigger) {
if(selected > 0 ) selected--;
} else if (trigger == &buttonUpTrigger) {
if (selected > 0) selected--;
bSelectedChanged = true;
} else if(trigger == &buttonDownTrigger) {
} else if (trigger == &buttonDownTrigger) {
selected++;
if(selected >= valueButtons.size()) selected = valueButtons.size() - 1;
if (selected >= valueButtons.size()) selected = valueButtons.size() - 1;
bSelectedChanged = true;
}
}
}
void GuiSelectBox::Init(std::map<std::string,std::string> values, int32_t valueID) {
if((uint32_t)valueID >= values.size()) {
void GuiSelectBox::Init(std::map<std::string, std::string> values, int32_t valueID) {
if ((uint32_t) valueID >= values.size()) {
valueID = 0;
}
@ -141,7 +134,7 @@ void GuiSelectBox::Init(std::map<std::string,std::string> values, int32_t valueI
DeleteValueData();
if(valueImageData == NULL || valueSelectedImageData == NULL || valueHighlightedImageData == NULL) {
if (valueImageData == NULL || valueSelectedImageData == NULL || valueHighlightedImageData == NULL) {
return;
}
@ -150,8 +143,8 @@ void GuiSelectBox::Init(std::map<std::string,std::string> values, int32_t valueI
int32_t i = 0;
float imgScale = 1.0f;
std::map<std::string, std::string>::iterator itr;
for(itr = values.begin(); itr != values.end(); itr++) {
if(i == valueID) {
for (itr = values.begin(); itr != values.end(); itr++) {
if (i == valueID) {
topValueText.setText(itr->first.c_str());
}
@ -160,7 +153,7 @@ void GuiSelectBox::Init(std::map<std::string,std::string> values, int32_t valueI
valueButtons[i].valueButtonHighlightedImg = new GuiImage(valueHighlightedImageData);
valueButtons[i].valueButton = new GuiButton(valueButtons[i].valueButtonImg->getWidth() * imgScale, valueButtons[i].valueButtonImg->getHeight() * imgScale);
valueButtons[i].valueButtonText = new GuiText(itr->first.c_str(),32,glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
valueButtons[i].valueButtonText = new GuiText(itr->first.c_str(), 32, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
valueButtons[i].valueButtonText->setMaxWidth(valueButtons[i].valueButtonImg->getWidth() * imgScale - 20.0f, GuiText::WRAP);
valueButtons[i].valueButtonText->setPosition(0, 0);
@ -172,7 +165,7 @@ void GuiSelectBox::Init(std::map<std::string,std::string> values, int32_t valueI
valueButtons[i].valueButton->setIconOver(valueButtons[i].valueButtonHighlightedImg);
valueButtons[i].valueButton->setTrigger(&touchTrigger);
valueButtons[i].valueButton->setTrigger(&wpadTouchTrigger);
valueButtons[i].valueButton->clicked.connect(this,&GuiSelectBox::OnValueClicked);
valueButtons[i].valueButton->clicked.connect(this, &GuiSelectBox::OnValueClicked);
valueButtons[i].valueButton->setSoundClick(buttonClickSound);
valueButtons[i].valueButton->setLabel(valueButtons[i].valueButtonText);
@ -181,11 +174,11 @@ void GuiSelectBox::Init(std::map<std::string,std::string> values, int32_t valueI
buttonToValue[valueButtons[i].valueButton] = itr->second;
float topHeight = 0;
if(topBackgroundImg != NULL) {
if (topBackgroundImg != NULL) {
topHeight = topBackgroundImg->getHeight();
}
int32_t ypos = (((valueButtons[i].valueButtonImg->getHeight()*getScale()) * (i))+ (topHeight-5)*getScale())*-1.0f;
int32_t ypos = (((valueButtons[i].valueButtonImg->getHeight() * getScale()) * (i)) + (topHeight - 5) * getScale()) * -1.0f;
valueButtons[i].valueButton->setPosition(0, ypos);
valuesFrame.append(valueButtons[i].valueButton);
@ -198,7 +191,7 @@ void GuiSelectBox::Init(std::map<std::string,std::string> values, int32_t valueI
}
void GuiSelectBox::DeleteValueData() {
for(uint32_t i = 0; i < valueButtons.size(); ++i) {
for (uint32_t i = 0; i < valueButtons.size(); ++i) {
valuesFrame.remove(valueButtons[i].valueButton);
delete valueButtons[i].valueButtonImg;
delete valueButtons[i].valueButtonCheckedImg;
@ -230,14 +223,14 @@ void GuiSelectBox::OnValueCloseEffectFinish(GuiElement *element) {
}
float GuiSelectBox::getTopValueHeight() {
if(topBackgroundImg == NULL) {
if (topBackgroundImg == NULL) {
return 0.0f;
}
return topBackgroundImg->getHeight();
}
float GuiSelectBox::getTopValueWidth() {
if(topBackgroundImg == NULL) {
if (topBackgroundImg == NULL) {
return 0.0f;
}
return topBackgroundImg->getWidth();
@ -257,12 +250,12 @@ void GuiSelectBox::OnValueOpenEffectFinish(GuiElement *element) {
opened = true;
}
void GuiSelectBox::update(GuiController * c) {
if(bChanged) {
showhide(this,showValues);
if(showValues) {
for(uint32_t i = 0; i < valueButtons.size(); ++i) { //TODO: only set when it really changed
if(i == selected) {
void GuiSelectBox::update(GuiController *c) {
if (bChanged) {
showhide(this, showValues);
if (showValues) {
for (uint32_t i = 0; i < valueButtons.size(); ++i) { //TODO: only set when it really changed
if (i == selected) {
valueButtons[i].valueButton->setImage(valueButtons[i].valueButtonCheckedImg);
} else {
valueButtons[i].valueButton->setImage(valueButtons[i].valueButtonImg);
@ -282,9 +275,9 @@ void GuiSelectBox::update(GuiController * c) {
bChanged = false;
}
if(bSelectedChanged) {
for(uint32_t i = 0; i < valueButtons.size(); ++i) {
if(i == selected) {
if (bSelectedChanged) {
for (uint32_t i = 0; i < valueButtons.size(); ++i) {
if (i == selected) {
valueButtons[i].valueButton->setState(STATE_SELECTED);
} else {
valueButtons[i].valueButton->clearState(STATE_SELECTED);

80
source/gui/GuiSound.cpp
View File

@ -20,36 +20,36 @@
#include <gui/GuiSound.h>
#include <gui/sounds/SoundHandler.hpp>
GuiSound::GuiSound(const char * filepath) {
GuiSound::GuiSound(const char *filepath) {
voice = -1;
Load(filepath);
}
GuiSound::GuiSound(const uint8_t * snd, int32_t length) {
GuiSound::GuiSound(const uint8_t *snd, int32_t length) {
voice = -1;
Load(snd, length);
}
GuiSound::~GuiSound() {
if(voice >= 0) {
if (voice >= 0) {
SoundHandler::instance()->RemoveDecoder(voice);
}
}
bool GuiSound::Load(const char * filepath) {
if(voice >= 0) {
bool GuiSound::Load(const char *filepath) {
if (voice >= 0) {
SoundHandler::instance()->RemoveDecoder(voice);
voice = -1;
}
//! find next free decoder
for(int32_t i = 0; i < MAX_DECODERS; i++) {
SoundDecoder * decoder = SoundHandler::instance()->getDecoder(i);
if(decoder == NULL) {
for (int32_t i = 0; i < MAX_DECODERS; i++) {
SoundDecoder *decoder = SoundHandler::instance()->getDecoder(i);
if (decoder == NULL) {
SoundHandler::instance()->AddDecoder(i, filepath);
decoder = SoundHandler::instance()->getDecoder(i);
if(decoder) {
if (decoder) {
voice = i;
SoundHandler::instance()->ThreadSignal();
}
@ -57,29 +57,29 @@ bool GuiSound::Load(const char * filepath) {
}
}
if(voice < 0) {
if (voice < 0) {
return false;
}
return true;
}
bool GuiSound::Load(const uint8_t * snd, int32_t len) {
if(voice >= 0) {
bool GuiSound::Load(const uint8_t *snd, int32_t len) {
if (voice >= 0) {
SoundHandler::instance()->RemoveDecoder(voice);
voice = -1;
}
if(!snd)
if (!snd)
return false;
//! find next free decoder
for(int32_t i = 0; i < MAX_DECODERS; i++) {
SoundDecoder * decoder = SoundHandler::instance()->getDecoder(i);
if(decoder == NULL) {
for (int32_t i = 0; i < MAX_DECODERS; i++) {
SoundDecoder *decoder = SoundHandler::instance()->getDecoder(i);
if (decoder == NULL) {
SoundHandler::instance()->AddDecoder(i, snd, len);
decoder = SoundHandler::instance()->getDecoder(i);
if(decoder) {
if (decoder) {
voice = i;
SoundHandler::instance()->ThreadSignal();
}
@ -87,7 +87,7 @@ bool GuiSound::Load(const uint8_t * snd, int32_t len) {
}
}
if(voice < 0) {
if (voice < 0) {
return false;
}
@ -97,25 +97,25 @@ bool GuiSound::Load(const uint8_t * snd, int32_t len) {
void GuiSound::Play() {
Stop();
Voice * v = SoundHandler::instance()->getVoice(voice);
if(v)
Voice *v = SoundHandler::instance()->getVoice(voice);
if (v)
v->setState(Voice::STATE_START);
}
void GuiSound::Stop() {
Voice * v = SoundHandler::instance()->getVoice(voice);
if(v) {
if((v->getState() != Voice::STATE_STOP) && (v->getState() != Voice::STATE_STOPPED))
Voice *v = SoundHandler::instance()->getVoice(voice);
if (v) {
if ((v->getState() != Voice::STATE_STOP) && (v->getState() != Voice::STATE_STOPPED))
v->setState(Voice::STATE_STOP);
while(v->getState() != Voice::STATE_STOPPED)
while (v->getState() != Voice::STATE_STOPPED)
OSSleepTicks(OSMicrosecondsToTicks(1000));
}
SoundDecoder * decoder = SoundHandler::instance()->getDecoder(voice);
if(decoder) {
SoundDecoder *decoder = SoundHandler::instance()->getDecoder(voice);
if (decoder) {
decoder->Lock();
decoder->Rewind();
decoder->ClearBuffer();
@ -125,45 +125,45 @@ void GuiSound::Stop() {
}
void GuiSound::Pause() {
if(!IsPlaying())
if (!IsPlaying())
return;
Voice * v = SoundHandler::instance()->getVoice(voice);
if(v)
Voice *v = SoundHandler::instance()->getVoice(voice);
if (v)
v->setState(Voice::STATE_STOP);
}
void GuiSound::Resume() {
if(IsPlaying())
if (IsPlaying())
return;
Voice * v = SoundHandler::instance()->getVoice(voice);
if(v)
Voice *v = SoundHandler::instance()->getVoice(voice);
if (v)
v->setState(Voice::STATE_START);
}
bool GuiSound::IsPlaying() {
Voice * v = SoundHandler::instance()->getVoice(voice);
if(v) {
Voice *v = SoundHandler::instance()->getVoice(voice);
if (v) {
return v->getState() == Voice::STATE_PLAYING;
}
return false;
}
void GuiSound::SetVolume(uint32_t vol) {
if(vol > 100)
if (vol > 100)
vol = 100;
uint32_t volumeConv = ( (0x8000 * vol) / 100 ) << 16;
uint32_t volumeConv = ((0x8000 * vol) / 100) << 16;
Voice * v = SoundHandler::instance()->getVoice(voice);
if(v)
Voice *v = SoundHandler::instance()->getVoice(voice);
if (v)
v->setVolume(volumeConv);
}
void GuiSound::SetLoop(bool l) {
SoundDecoder * decoder = SoundHandler::instance()->getDecoder(voice);
if(decoder)
SoundDecoder *decoder = SoundHandler::instance()->getDecoder(voice);
if (decoder)
decoder->SetLoop(l);
}

26
source/gui/GuiSwitch.cpp
View File

@ -17,14 +17,16 @@
#include <gui/GuiSwitch.h>
#include <gui/GuiImage.h>
#include <gui/GuiImageData.h>
/**
* Constructor for the GuiSwitch class.
*/
GuiSwitch::GuiSwitch(GuiImage * background,bool checked,float w, float h)
: GuiToggle(checked,w,h) {
GuiSwitch::GuiSwitch(GuiImage *background, bool checked, float w, float h)
: GuiToggle(checked, w, h) {
setImageBackground(background);
}
/**
* Destructor for the GuiSwitch class.
*/
@ -32,43 +34,43 @@ GuiSwitch::~GuiSwitch() {
}
void GuiSwitch::setImageBackground(GuiImage* img) {
void GuiSwitch::setImageBackground(GuiImage *img) {
backgroundImg = img;
if(img) {
if (img) {
img->setParent(this);
}
setImage(img);
}
void GuiSwitch::setImageOn(GuiImage* img) {
void GuiSwitch::setImageOn(GuiImage *img) {
onImg = img;
if(img) {
if (img) {
img->setParent(this);
img->setAlignment(ALIGN_RIGHT);
}
}
void GuiSwitch::setImageOff(GuiImage* img) {
void GuiSwitch::setImageOff(GuiImage *img) {
offImg = img;
if(img) {
if (img) {
img->setParent(this);
img->setAlignment(ALIGN_LEFT);
}
}
void GuiSwitch::setImageHighlighted(GuiImage* img) {
void GuiSwitch::setImageHighlighted(GuiImage *img) {
highlightedImg = img;
setIconOver(img);
}
void GuiSwitch::draw(CVideo *v) {
GuiToggle::draw(v);
if(getValue()) {
if(onImg != NULL) {
if (getValue()) {
if (onImg != NULL) {
onImg->draw(v);
}
} else {
if(offImg != NULL) {
if (offImg != NULL) {
offImg->draw(v);
}
}

164
source/gui/GuiText.cpp
View File

@ -18,18 +18,18 @@
#include <gui/FreeTypeGX.h>
#include <gui/video/CVideo.h>
FreeTypeGX * GuiText::presentFont = NULL;
FreeTypeGX *GuiText::presentFont = NULL;
int32_t GuiText::presetSize = 28;
float GuiText::presetInternalRenderingScale = 2.0f; //Lets render the font at the doubled size. This make it even smoother!
int32_t GuiText::presetMaxWidth = 0xFFFF;
int32_t GuiText::presetAlignment = ALIGN_CENTER | ALIGN_MIDDLE;
GX2ColorF32 GuiText::presetColor = (GX2ColorF32) {
1.0f, 1.0f, 1.0f, 1.0f
1.0f, 1.0f, 1.0f, 1.0f
};
#define TEXT_SCROLL_DELAY 6
#define TEXT_SCROLL_INITIAL_DELAY 10
#define MAX_LINES_TO_DRAW 10
#define TEXT_SCROLL_DELAY 6
#define TEXT_SCROLL_INITIAL_DELAY 10
#define MAX_LINES_TO_DRAW 10
/**
* Constructor for the GuiText class.
@ -57,7 +57,7 @@ GuiText::GuiText() {
internalRenderingScale = presetInternalRenderingScale;
}
GuiText::GuiText(const char * t, int32_t s, const glm::vec4 & c) {
GuiText::GuiText(const char *t, int32_t s, const glm::vec4 &c) {
text = NULL;
size = s;
currentSize = size;
@ -78,16 +78,16 @@ GuiText::GuiText(const char * t, int32_t s, const glm::vec4 & c) {
blurGlowColor = glm::vec4(0.0f);
internalRenderingScale = presetInternalRenderingScale;
if(t) {
if (t) {
text = FreeTypeGX::charToWideChar(t);
if(!text)
if (!text)
return;
textWidth = font->getWidth(text, currentSize);
}
}
GuiText::GuiText(const wchar_t * t, int32_t s, const glm::vec4 & c) {
GuiText::GuiText(const wchar_t *t, int32_t s, const glm::vec4 &c) {
text = NULL;
size = s;
currentSize = size;
@ -108,9 +108,9 @@ GuiText::GuiText(const wchar_t * t, int32_t s, const glm::vec4 & c) {
blurGlowColor = glm::vec4(0.0f);
internalRenderingScale = presetInternalRenderingScale;
if(t) {
text = new (std::nothrow) wchar_t[wcslen(t)+1];
if(!text)
if (t) {
text = new(std::nothrow) wchar_t[wcslen(t) + 1];
if (!text)
return;
wcscpy(text, t);
@ -122,7 +122,7 @@ GuiText::GuiText(const wchar_t * t, int32_t s, const glm::vec4 & c) {
/**
* Constructor for the GuiText class, uses presets
*/
GuiText::GuiText(const char * t) {
GuiText::GuiText(const char *t) {
text = NULL;
size = presetSize;
currentSize = size;
@ -143,9 +143,9 @@ GuiText::GuiText(const char * t) {
blurGlowColor = glm::vec4(0.0f);
internalRenderingScale = presetInternalRenderingScale;
if(t) {
if (t) {
text = FreeTypeGX::charToWideChar(t);
if(!text)
if (!text)
return;
textWidth = font->getWidth(text, currentSize);
@ -157,16 +157,16 @@ GuiText::GuiText(const char * t) {
* Destructor for the GuiText class.
*/
GuiText::~GuiText() {
if(text)
delete [] text;
if (text)
delete[] text;
text = NULL;
clearDynamicText();
}
void GuiText::setText(const char * t) {
if(text)
delete [] text;
void GuiText::setText(const char *t) {
if (text)
delete[] text;
text = NULL;
clearDynamicText();
@ -174,9 +174,9 @@ void GuiText::setText(const char * t) {
textScrollPos = 0;
textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
if(t) {
if (t) {
text = FreeTypeGX::charToWideChar(t);
if(!text)
if (!text)
return;
textWidth = font->getWidth(text, currentSize);
@ -184,7 +184,7 @@ void GuiText::setText(const char * t) {
}
void GuiText::setTextf(const char *format, ...) {
if(!format) {
if (!format) {
setText((char *) NULL);
return;
}
@ -193,19 +193,19 @@ void GuiText::setTextf(const char *format, ...) {
char *tmp = new char[max_len];
va_list va;
va_start(va, format);
if((vsnprintf(tmp, max_len, format, va) >= 0) && tmp) {
if ((vsnprintf(tmp, max_len, format, va) >= 0) && tmp) {
setText(tmp);
}
va_end(va);
if(tmp)
delete [] tmp;
if (tmp)
delete[] tmp;
}
void GuiText::setText(const wchar_t * t) {
if(text)
delete [] text;
void GuiText::setText(const wchar_t *t) {
if (text)
delete[] text;
text = NULL;
clearDynamicText();
@ -213,9 +213,9 @@ void GuiText::setText(const wchar_t * t) {
textScrollPos = 0;
textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
if(t) {
text = new (std::nothrow) wchar_t[wcslen(t)+1];
if(!text)
if (t) {
text = new(std::nothrow) wchar_t[wcslen(t) + 1];
if (!text)
return;
wcscpy(text, t);
@ -225,18 +225,18 @@ void GuiText::setText(const wchar_t * t) {
}
void GuiText::clearDynamicText() {
for(uint32_t i = 0; i < textDyn.size(); i++) {
if(textDyn[i])
delete [] textDyn[i];
for (uint32_t i = 0; i < textDyn.size(); i++) {
if (textDyn[i])
delete[] textDyn[i];
}
textDyn.clear();
textDynWidth.clear();
}
void GuiText::setPresets(int32_t sz, const glm::vec4 & c, int32_t w, int32_t a) {
void GuiText::setPresets(int32_t sz, const glm::vec4 &c, int32_t w, int32_t a) {
presetSize = sz;
presetColor = (GX2ColorF32) {
(float)c.r / 255.0f, (float)c.g / 255.0f, (float)c.b / 255.0f, (float)c.a / 255.0f
(float) c.r / 255.0f, (float) c.g / 255.0f, (float) c.b / 255.0f, (float) c.a / 255.0f
};
presetMaxWidth = w;
presetAlignment = a;
@ -254,7 +254,7 @@ void GuiText::setMaxWidth(int32_t width, int32_t w) {
maxWidth = width;
wrapMode = w;
if(w == SCROLL_HORIZONTAL) {
if (w == SCROLL_HORIZONTAL) {
textScrollPos = 0;
textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
textScrollDelay = TEXT_SCROLL_DELAY;
@ -263,26 +263,26 @@ void GuiText::setMaxWidth(int32_t width, int32_t w) {
clearDynamicText();
}
void GuiText::setColor(const glm::vec4 & c) {
void GuiText::setColor(const glm::vec4 &c) {
color = c;
alpha = c[3];
}
void GuiText::setBlurGlowColor(float blur, const glm::vec4 & c) {
void GuiText::setBlurGlowColor(float blur, const glm::vec4 &c) {
blurGlowColor = c;
blurGlowIntensity = blur;
blurAlpha = c[3];
}
int32_t GuiText::getTextWidth(int32_t ind) {
if(ind < 0 || ind >= (int32_t) textDyn.size())
if (ind < 0 || ind >= (int32_t) textDyn.size())
return this->getTextWidth();
return font->getWidth(textDyn[ind], currentSize);
}
const wchar_t * GuiText::getDynText(int32_t ind) {
if(ind < 0 || ind >= (int32_t) textDyn.size())
const wchar_t *GuiText::getDynText(int32_t ind) {
if (ind < 0 || ind >= (int32_t) textDyn.size())
return text;
return textDyn[ind];
@ -292,7 +292,7 @@ const wchar_t * GuiText::getDynText(int32_t ind) {
* Change font
*/
bool GuiText::setFont(FreeTypeGX *f) {
if(!f)
if (!f)
return false;
font = f;
@ -301,16 +301,16 @@ bool GuiText::setFont(FreeTypeGX *f) {
}
std::string GuiText::toUTF8(void) const {
if(!text)
if (!text)
return std::string();
char *pUtf8 = FreeTypeGX::wideCharToUTF8(text);
if(!pUtf8)
if (!pUtf8)
return std::string();
std::string strOutput(pUtf8);
delete [] pUtf8;
delete[] pUtf8;
return strOutput;
}
@ -320,8 +320,8 @@ void GuiText::makeDottedText() {
textDyn.resize(pos + 1);
int32_t i = 0, currentWidth = 0;
textDyn[pos] = new (std::nothrow) wchar_t[maxWidth];
if(!textDyn[pos]) {
textDyn[pos] = new(std::nothrow) wchar_t[maxWidth];
if (!textDyn[pos]) {
textDyn.resize(pos);
return;
}
@ -349,8 +349,8 @@ void GuiText::scrollText(uint32_t frameCount) {
int32_t i = 0, currentWidth = 0;
textDyn.resize(pos + 1);
textDyn[pos] = new (std::nothrow) wchar_t[maxWidth];
if(!textDyn[pos]) {
textDyn[pos] = new(std::nothrow) wchar_t[maxWidth];
if (!textDyn[pos]) {
textDyn.resize(pos);
return;
}
@ -388,9 +388,9 @@ void GuiText::scrollText(uint32_t frameCount) {
int32_t pos = textDyn.size() - 1;
if (!textDyn[pos])
textDyn[pos] = new (std::nothrow) wchar_t[maxWidth];
textDyn[pos] = new(std::nothrow) wchar_t[maxWidth];
if(!textDyn[pos]) {
if (!textDyn[pos]) {
textDyn.resize(pos);
return;
}
@ -407,7 +407,7 @@ void GuiText::scrollText(uint32_t frameCount) {
currentWidth += font->getCharWidth(L' ', currentSize, L' ');
ch = 0;
if(currentWidth >= maxWidth)
if (currentWidth >= maxWidth)
break;
}
@ -432,8 +432,8 @@ void GuiText::wrapText() {
while (text[ch] && linenum < linestodraw) {
if (linenum >= (int32_t) textDyn.size()) {
textDyn.resize(linenum + 1);
textDyn[linenum] = new (std::nothrow) wchar_t[maxWidth];
if(!textDyn[linenum]) {
textDyn[linenum] = new(std::nothrow) wchar_t[maxWidth];
if (!textDyn[linenum]) {
textDyn.resize(linenum);
break;
}
@ -445,7 +445,7 @@ void GuiText::wrapText() {
currentWidth += font->getCharWidth(text[ch], currentSize, ch > 0 ? text[ch - 1] : 0x0000);
if (currentWidth >= maxWidth || (text[ch] == '\n')) {
if(text[ch] == '\n') {
if (text[ch] == '\n') {
lastSpace = -1;
lastSpaceIndex = -1;
} else if (lastSpace >= 0) {
@ -456,7 +456,7 @@ void GuiText::wrapText() {
}
if (linenum + 1 == linestodraw && text[ch + 1] != 0x0000) {
if(i < 2)
if (i < 2)
i = 2;
textDyn[linenum][i - 2] = '.';
@ -482,10 +482,10 @@ void GuiText::wrapText() {
* Draw the text on screen
*/
void GuiText::draw(CVideo *pVideo) {
if(!text)
if (!text)
return;
if(!isVisible())
if (!isVisible())
return;
color[3] = getAlpha();
@ -496,64 +496,62 @@ void GuiText::draw(CVideo *pVideo) {
int32_t newSize = size * getScale() * finalRenderingScale;
int32_t normal_size = size * getScale();
if(newSize != currentSize) {
if (newSize != currentSize) {
currentSize = normal_size;
if(text)
if (text)
textWidth = font->getWidth(text, normal_size);
}
float x_pos = getCenterX() * finalRenderingScale;
float y_pos = getCenterY() * finalRenderingScale;
if(maxWidth > 0 && maxWidth <= textWidth) {
if(wrapMode == DOTTED) { // text dotted
if(textDyn.size() == 0)
if (maxWidth > 0 && maxWidth <= textWidth) {
if (wrapMode == DOTTED) { // text dotted
if (textDyn.size() == 0)
makeDottedText();
if(textDynWidth.size() != textDyn.size()) {
if (textDynWidth.size() != textDyn.size()) {
textDynWidth.resize(textDyn.size());
for(uint32_t i = 0; i < textDynWidth.size(); i++)
for (uint32_t i = 0; i < textDynWidth.size(); i++)
textDynWidth[i] = font->getWidth(textDyn[i], newSize);
}
if(textDyn.size() > 0)
font->drawText(pVideo, x_pos, y_pos, getDepth(), textDyn[textDyn.size()-1], newSize, color, alignment, textDynWidth[textDyn.size()-1], defaultBlur, blurGlowIntensity, blurGlowColor,finalRenderingScale);
}
else if(wrapMode == SCROLL_HORIZONTAL) {
if (textDyn.size() > 0)
font->drawText(pVideo, x_pos, y_pos, getDepth(), textDyn[textDyn.size() - 1], newSize, color, alignment, textDynWidth[textDyn.size() - 1], defaultBlur, blurGlowIntensity, blurGlowColor, finalRenderingScale);
} else if (wrapMode == SCROLL_HORIZONTAL) {
scrollText(pVideo->getFrameCount());
if(textDyn.size() > 0)
font->drawText(pVideo, x_pos, y_pos, getDepth(), textDyn[textDyn.size()-1], newSize, color, alignment, maxWidth*finalRenderingScale, defaultBlur, blurGlowIntensity, blurGlowColor,finalRenderingScale);
if (textDyn.size() > 0)
font->drawText(pVideo, x_pos, y_pos, getDepth(), textDyn[textDyn.size() - 1], newSize, color, alignment, maxWidth * finalRenderingScale, defaultBlur, blurGlowIntensity, blurGlowColor, finalRenderingScale);
} else if(wrapMode == WRAP) {
} else if (wrapMode == WRAP) {
int32_t lineheight = newSize + 6;
int32_t yoffset = 0;
int32_t voffset = 0;
if(textDyn.size() == 0)
if (textDyn.size() == 0)
wrapText();
if(textDynWidth.size() != textDyn.size()) {
if (textDynWidth.size() != textDyn.size()) {
textDynWidth.resize(textDyn.size());
for(uint32_t i = 0; i < textDynWidth.size(); i++)
for (uint32_t i = 0; i < textDynWidth.size(); i++)
textDynWidth[i] = font->getWidth(textDyn[i], newSize);
}
if(alignment & ALIGN_MIDDLE)
voffset = (lineheight * (textDyn.size()-1)) >> 1;
if (alignment & ALIGN_MIDDLE)
voffset = (lineheight * (textDyn.size() - 1)) >> 1;
for(uint32_t i = 0; i < textDyn.size(); i++) {
font->drawText(pVideo, x_pos, y_pos + voffset + yoffset, getDepth(), textDyn[i], newSize, color, alignment, textDynWidth[i], defaultBlur, blurGlowIntensity, blurGlowColor,finalRenderingScale);
for (uint32_t i = 0; i < textDyn.size(); i++) {
font->drawText(pVideo, x_pos, y_pos + voffset + yoffset, getDepth(), textDyn[i], newSize, color, alignment, textDynWidth[i], defaultBlur, blurGlowIntensity, blurGlowColor, finalRenderingScale);
yoffset -= lineheight;
}
}
} else {
uint16_t newtextWidth = font->getWidth(text, newSize);
font->drawText(pVideo, x_pos, y_pos, getDepth(), text, newSize, color, alignment, newtextWidth, defaultBlur, blurGlowIntensity, blurGlowColor,finalRenderingScale);
font->drawText(pVideo, x_pos, y_pos, getDepth(), text, newSize, color, alignment, newtextWidth, defaultBlur, blurGlowIntensity, blurGlowColor, finalRenderingScale);
}
}

13
source/gui/GuiToggle.cpp
View File

@ -15,15 +15,16 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <gui/GuiToggle.h>
/**
* Constructor for the GuiToggle class.
*/
GuiToggle::GuiToggle(bool checked,float width,float height)
: GuiButton(width,height) {
GuiToggle::GuiToggle(bool checked, float width, float height)
: GuiButton(width, height) {
bChanged = false;
selected = checked;
clicked.connect(this,&GuiToggle::OnToggleClick);
clicked.connect(this, &GuiToggle::OnToggleClick);
}
/**
@ -35,8 +36,8 @@ GuiToggle::~GuiToggle() {
}
void GuiToggle::OnToggleClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger) {
if(!isStateSet(STATE_DISABLED | STATE_HIDDEN | STATE_DISABLE_INPUT)) {
if(selected) {
if (!isStateSet(STATE_DISABLED | STATE_HIDDEN | STATE_DISABLE_INPUT)) {
if (selected) {
setUnchecked();
} else {
setChecked();
@ -44,7 +45,7 @@ void GuiToggle::OnToggleClick(GuiButton *button, const GuiController *controller
}
}
void GuiToggle::update(GuiController * c) {
void GuiToggle::update(GuiController *c) {
GuiButton::update(c);
}

50
source/gui/GuiTrigger.cpp
View File

@ -22,21 +22,11 @@
* Constructor for the GuiTrigger class.
*/
GuiTrigger::GuiTrigger()
: chan(CHANNEL_ALL)
, btns(BUTTON_NONE)
, bClickEverywhere(false)
, bHoldEverywhere(false)
, bSelectionClickEverywhere(false)
, bLastTouched(false) {
: chan(CHANNEL_ALL), btns(BUTTON_NONE), bClickEverywhere(false), bHoldEverywhere(false), bSelectionClickEverywhere(false), bLastTouched(false) {
}
GuiTrigger::GuiTrigger(uint32_t ch, uint32_t btn, bool clickEverywhere, bool holdEverywhere, bool selectionClickEverywhere)
: chan(ch)
, btns(btn)
, bClickEverywhere(clickEverywhere)
, bHoldEverywhere(holdEverywhere)
, bSelectionClickEverywhere(selectionClickEverywhere)
, bLastTouched(false) {
: chan(ch), btns(btn), bClickEverywhere(clickEverywhere), bHoldEverywhere(holdEverywhere), bSelectionClickEverywhere(selectionClickEverywhere), bLastTouched(false) {
}
/**
@ -56,74 +46,74 @@ void GuiTrigger::setTrigger(uint32_t ch, uint32_t btn) {
}
bool GuiTrigger::left(const GuiController *controller) const {
if((controller->chan & chan) == 0) {
if ((controller->chan & chan) == 0) {
return false;
}
if((controller->data.buttons_h | controller->data.buttons_d) & (BUTTON_LEFT | STICK_L_LEFT)) {
if ((controller->data.buttons_h | controller->data.buttons_d) & (BUTTON_LEFT | STICK_L_LEFT)) {
return true;
}
return false;
}
bool GuiTrigger::right(const GuiController *controller) const {
if((controller->chan & chan) == 0) {
if ((controller->chan & chan) == 0) {
return false;
}
if((controller->data.buttons_h | controller->data.buttons_d) & (BUTTON_RIGHT | STICK_L_RIGHT)) {
if ((controller->data.buttons_h | controller->data.buttons_d) & (BUTTON_RIGHT | STICK_L_RIGHT)) {
return true;
}
return false;
}
bool GuiTrigger::up(const GuiController *controller) const {
if((controller->chan & chan) == 0) {
if ((controller->chan & chan) == 0) {
return false;
}
if((controller->data.buttons_h | controller->data.buttons_d) & (BUTTON_UP | STICK_L_UP)) {
if ((controller->data.buttons_h | controller->data.buttons_d) & (BUTTON_UP | STICK_L_UP)) {
return true;
}
return false;
}
bool GuiTrigger::down(const GuiController *controller) const {
if((controller->chan & chan) == 0) {
if ((controller->chan & chan) == 0) {
return false;
}
if((controller->data.buttons_h | controller->data.buttons_d) & (BUTTON_DOWN | STICK_L_DOWN)) {
if ((controller->data.buttons_h | controller->data.buttons_d) & (BUTTON_DOWN | STICK_L_DOWN)) {
return true;
}
return false;
}
int32_t GuiTrigger::clicked(const GuiController *controller) const {
if((controller->chan & chan) == 0) {
if ((controller->chan & chan) == 0) {
return CLICKED_NONE;
}
int32_t bResult = CLICKED_NONE;
if(controller->data.touched && controller->data.validPointer && (btns & VPAD_TOUCH) && !controller->lastData.touched) {
if (controller->data.touched && controller->data.validPointer && (btns & VPAD_TOUCH) && !controller->lastData.touched) {
bResult = CLICKED_TOUCH;
}
if(controller->data.buttons_d & btns) {
if (controller->data.buttons_d & btns) {
bResult = CLICKED_BUTTON;
}
return bResult;
}
bool GuiTrigger::held(const GuiController *controller) const {
if((controller->chan & chan) == 0) {
if ((controller->chan & chan) == 0) {
return false;
}
bool bResult = false;
if(controller->data.touched && (btns & VPAD_TOUCH) && controller->data.validPointer && controller->lastData.touched && controller->lastData.validPointer) {
if (controller->data.touched && (btns & VPAD_TOUCH) && controller->data.validPointer && controller->lastData.touched && controller->lastData.validPointer) {
bResult = true;
}
if(controller->data.buttons_h & btns) {
if (controller->data.buttons_h & btns) {
bResult = true;
}
@ -131,20 +121,20 @@ bool GuiTrigger::held(const GuiController *controller) const {
}
bool GuiTrigger::released(const GuiController *controller) const {
if((controller->chan & chan) == 0) {
if ((controller->chan & chan) == 0) {
return false;
}
if(clicked(controller) || held(controller))
if (clicked(controller) || held(controller))
return false;
bool bResult = false;
if(!controller->data.touched && (btns & VPAD_TOUCH) && controller->lastData.touched && controller->lastData.validPointer) {
if (!controller->data.touched && (btns & VPAD_TOUCH) && controller->lastData.touched && controller->lastData.validPointer) {
bResult = true;
}
if(controller->data.buttons_r & btns) {
if (controller->data.buttons_r & btns) {
bResult = true;
}

34
source/sounds/BufferCircle.cpp
View File

@ -40,13 +40,13 @@ BufferCircle::~BufferCircle() {
}
void BufferCircle::SetBufferBlockSize(int32_t size) {
if(size < 0)
if (size < 0)
return;
BufferBlockSize = size;
for(int32_t i = 0; i < Size(); i++) {
if(SoundBuffer[i] != NULL)
for (int32_t i = 0; i < Size(); i++) {
if (SoundBuffer[i] != NULL)
free(SoundBuffer[i]);
SoundBuffer[i] = (uint8_t *) memalign(32, ALIGN32(BufferBlockSize));
@ -56,8 +56,8 @@ void BufferCircle::SetBufferBlockSize(int32_t size) {
}
void BufferCircle::Resize(int32_t size) {
while(size < Size())
RemoveBuffer(Size()-1);
while (size < Size())
RemoveBuffer(Size() - 1);
int32_t oldSize = Size();
@ -65,8 +65,8 @@ void BufferCircle::Resize(int32_t size) {
BufferSize.resize(size);
BufferReady.resize(size);
for(int32_t i = oldSize; i < Size(); i++) {
if(BufferBlockSize > 0)
for (int32_t i = oldSize; i < Size(); i++) {
if (BufferBlockSize > 0)
SoundBuffer[i] = (uint8_t *) memalign(32, ALIGN32(BufferBlockSize));
else
SoundBuffer[i] = NULL;
@ -76,19 +76,19 @@ void BufferCircle::Resize(int32_t size) {
}
void BufferCircle::RemoveBuffer(int32_t pos) {
if(!Valid(pos))
if (!Valid(pos))
return;
if(SoundBuffer[pos] != NULL)
if (SoundBuffer[pos] != NULL)
free(SoundBuffer[pos]);
SoundBuffer.erase(SoundBuffer.begin()+pos);
BufferSize.erase(BufferSize.begin()+pos);
BufferReady.erase(BufferReady.begin()+pos);
SoundBuffer.erase(SoundBuffer.begin() + pos);
BufferSize.erase(BufferSize.begin() + pos);
BufferReady.erase(BufferReady.begin() + pos);
}
void BufferCircle::ClearBuffer() {
for(int32_t i = 0; i < Size(); i++) {
for (int32_t i = 0; i < Size(); i++) {
BufferSize[i] = 0;
BufferReady[i] = false;
}
@ -96,8 +96,8 @@ void BufferCircle::ClearBuffer() {
}
void BufferCircle::FreeBuffer() {
for(int32_t i = 0; i < Size(); i++) {
if(SoundBuffer[i] != NULL)
for (int32_t i = 0; i < Size(); i++) {
if (SoundBuffer[i] != NULL)
free(SoundBuffer[i]);
SoundBuffer[i] = NULL;
@ -114,14 +114,14 @@ void BufferCircle::LoadNext() {
}
void BufferCircle::SetBufferReady(int32_t pos, bool state) {
if(!Valid(pos))
if (!Valid(pos))
return;
BufferReady[pos] = state;
}
void BufferCircle::SetBufferSize(int32_t pos, int32_t size) {
if(!Valid(pos))
if (!Valid(pos))
return;
BufferSize[pos] = size;

277
source/sounds/Mp3Decoder.cpp
View File

@ -34,186 +34,167 @@
#include <gui/sounds/Mp3Decoder.hpp>
#include "fs/CFile.hpp"
Mp3Decoder::Mp3Decoder(const char * filepath)
: SoundDecoder(filepath)
{
SoundType = SOUND_MP3;
ReadBuffer = NULL;
mad_timer_reset(&Timer);
mad_stream_init(&Stream);
mad_frame_init(&Frame);
mad_synth_init(&Synth);
Mp3Decoder::Mp3Decoder(const char *filepath)
: SoundDecoder(filepath) {
SoundType = SOUND_MP3;
ReadBuffer = NULL;
mad_timer_reset(&Timer);
mad_stream_init(&Stream);
mad_frame_init(&Frame);
mad_synth_init(&Synth);
if(!file_fd)
return;
if (!file_fd)
return;
OpenFile();
OpenFile();
}
Mp3Decoder::Mp3Decoder(const uint8_t * snd, int32_t len)
: SoundDecoder(snd, len)
{
SoundType = SOUND_MP3;
ReadBuffer = NULL;
mad_timer_reset(&Timer);
mad_stream_init(&Stream);
mad_frame_init(&Frame);
mad_synth_init(&Synth);
Mp3Decoder::Mp3Decoder(const uint8_t *snd, int32_t len)
: SoundDecoder(snd, len) {
SoundType = SOUND_MP3;
ReadBuffer = NULL;
mad_timer_reset(&Timer);
mad_stream_init(&Stream);
mad_frame_init(&Frame);
mad_synth_init(&Synth);
if(!file_fd)
return;
if (!file_fd)
return;
OpenFile();
OpenFile();
}
Mp3Decoder::~Mp3Decoder()
{
ExitRequested = true;
while(Decoding)
OSSleepTicks(OSMicrosecondsToTicks(100));
Mp3Decoder::~Mp3Decoder() {
ExitRequested = true;
while (Decoding)
OSSleepTicks(OSMicrosecondsToTicks(100));
mad_synth_finish(&Synth);
mad_frame_finish(&Frame);
mad_stream_finish(&Stream);
mad_synth_finish(&Synth);
mad_frame_finish(&Frame);
mad_stream_finish(&Stream);
if(ReadBuffer)
free(ReadBuffer);
ReadBuffer = NULL;
if (ReadBuffer)
free(ReadBuffer);
ReadBuffer = NULL;
}
void Mp3Decoder::OpenFile()
{
GuardPtr = NULL;
ReadBuffer = (uint8_t *) memalign(32, SoundBlockSize*SoundBlocks);
if(!ReadBuffer)
{
if(file_fd)
delete file_fd;
file_fd = NULL;
return;
}
void Mp3Decoder::OpenFile() {
GuardPtr = NULL;
ReadBuffer = (uint8_t *) memalign(32, SoundBlockSize * SoundBlocks);
if (!ReadBuffer) {
if (file_fd)
delete file_fd;
file_fd = NULL;
return;
}
uint8_t dummybuff[4096];
int32_t ret = Read(dummybuff, 4096, 0);
if(ret <= 0)
{
if(file_fd)
delete file_fd;
file_fd = NULL;
return;
}
uint8_t dummybuff[4096];
int32_t ret = Read(dummybuff, 4096, 0);
if (ret <= 0) {
if (file_fd)
delete file_fd;
file_fd = NULL;
return;
}
SampleRate = (uint32_t) Frame.header.samplerate;
Format = ((MAD_NCHANNELS(&Frame.header) == 2) ? (FORMAT_PCM_16_BIT | CHANNELS_STEREO) : (FORMAT_PCM_16_BIT | CHANNELS_MONO));
Rewind();
SampleRate = (uint32_t) Frame.header.samplerate;
Format = ((MAD_NCHANNELS(&Frame.header) == 2) ? (FORMAT_PCM_16_BIT | CHANNELS_STEREO) : (FORMAT_PCM_16_BIT | CHANNELS_MONO));
Rewind();
}
int32_t Mp3Decoder::Rewind()
{
mad_synth_finish(&Synth);
mad_frame_finish(&Frame);
mad_stream_finish(&Stream);
mad_timer_reset(&Timer);
mad_stream_init(&Stream);
mad_frame_init(&Frame);
mad_synth_init(&Synth);
SynthPos = 0;
GuardPtr = NULL;
int32_t Mp3Decoder::Rewind() {
mad_synth_finish(&Synth);
mad_frame_finish(&Frame);
mad_stream_finish(&Stream);
mad_timer_reset(&Timer);
mad_stream_init(&Stream);
mad_frame_init(&Frame);
mad_synth_init(&Synth);
SynthPos = 0;
GuardPtr = NULL;
if(!file_fd)
return -1;
if (!file_fd)
return -1;
return SoundDecoder::Rewind();
return SoundDecoder::Rewind();
}
static inline int16_t FixedToShort(mad_fixed_t Fixed)
{
/* Clipping */
if(Fixed>=MAD_F_ONE)
return(SHRT_MAX);
if(Fixed<=-MAD_F_ONE)
return(-SHRT_MAX);
static inline int16_t FixedToShort(mad_fixed_t Fixed) {
/* Clipping */
if (Fixed >= MAD_F_ONE)
return (SHRT_MAX);
if (Fixed <= -MAD_F_ONE)
return (-SHRT_MAX);
Fixed=Fixed>>(MAD_F_FRACBITS-15);
return((int16_t)Fixed);
Fixed = Fixed >> (MAD_F_FRACBITS - 15);
return ((int16_t) Fixed);
}
int32_t Mp3Decoder::Read(uint8_t * buffer, int32_t buffer_size, int32_t pos)
{
if(!file_fd)
return -1;
int32_t Mp3Decoder::Read(uint8_t *buffer, int32_t buffer_size, int32_t pos) {
if (!file_fd)
return -1;
if(Format == (FORMAT_PCM_16_BIT | CHANNELS_STEREO))
buffer_size &= ~0x0003;
else
buffer_size &= ~0x0001;
if (Format == (FORMAT_PCM_16_BIT | CHANNELS_STEREO))
buffer_size &= ~0x0003;
else
buffer_size &= ~0x0001;
uint8_t * write_pos = buffer;
uint8_t * write_end = buffer+buffer_size;
uint8_t *write_pos = buffer;
uint8_t *write_end = buffer + buffer_size;
while(1)
{
while(SynthPos < Synth.pcm.length)
{
if(write_pos >= write_end)
return write_pos-buffer;
while (1) {
while (SynthPos < Synth.pcm.length) {
if (write_pos >= write_end)
return write_pos - buffer;
*((int16_t *) write_pos) = FixedToShort(Synth.pcm.samples[0][SynthPos]);
write_pos += 2;
*((int16_t *) write_pos) = FixedToShort(Synth.pcm.samples[0][SynthPos]);
write_pos += 2;
if(MAD_NCHANNELS(&Frame.header) == 2)
{
*((int16_t *) write_pos) = FixedToShort(Synth.pcm.samples[1][SynthPos]);
write_pos += 2;
}
SynthPos++;
}
if (MAD_NCHANNELS(&Frame.header) == 2) {
*((int16_t *) write_pos) = FixedToShort(Synth.pcm.samples[1][SynthPos]);
write_pos += 2;
}
SynthPos++;
}
if(Stream.buffer == NULL || Stream.error == MAD_ERROR_BUFLEN)
{
uint8_t * ReadStart = ReadBuffer;
int32_t ReadSize = SoundBlockSize*SoundBlocks;
int32_t Remaining = 0;
if (Stream.buffer == NULL || Stream.error == MAD_ERROR_BUFLEN) {
uint8_t *ReadStart = ReadBuffer;
int32_t ReadSize = SoundBlockSize * SoundBlocks;
int32_t Remaining = 0;
if(Stream.next_frame != NULL)
{
Remaining = Stream.bufend - Stream.next_frame;
memmove(ReadBuffer, Stream.next_frame, Remaining);
ReadStart += Remaining;
ReadSize -= Remaining;
}
if (Stream.next_frame != NULL) {
Remaining = Stream.bufend - Stream.next_frame;
memmove(ReadBuffer, Stream.next_frame, Remaining);
ReadStart += Remaining;
ReadSize -= Remaining;
}
ReadSize = file_fd->read(ReadStart, ReadSize);
if(ReadSize <= 0)
{
GuardPtr = ReadStart;
memset(GuardPtr, 0, MAD_BUFFER_GUARD);
ReadSize = MAD_BUFFER_GUARD;
}
ReadSize = file_fd->read(ReadStart, ReadSize);
if (ReadSize <= 0) {
GuardPtr = ReadStart;
memset(GuardPtr, 0, MAD_BUFFER_GUARD);
ReadSize = MAD_BUFFER_GUARD;
}
CurPos += ReadSize;
mad_stream_buffer(&Stream, ReadBuffer, Remaining+ReadSize);
}
CurPos += ReadSize;
mad_stream_buffer(&Stream, ReadBuffer, Remaining + ReadSize);
}
if(mad_frame_decode(&Frame,&Stream))
{
if(MAD_RECOVERABLE(Stream.error))
{
if(Stream.error != MAD_ERROR_LOSTSYNC || !GuardPtr)
continue;
}
else
{
if(Stream.error != MAD_ERROR_BUFLEN)
return -1;
else if(Stream.error == MAD_ERROR_BUFLEN && GuardPtr)
return -1;
}
}
if (mad_frame_decode(&Frame, &Stream)) {
if (MAD_RECOVERABLE(Stream.error)) {
if (Stream.error != MAD_ERROR_LOSTSYNC || !GuardPtr)
continue;
} else {
if (Stream.error != MAD_ERROR_BUFLEN)
return -1;
else if (Stream.error == MAD_ERROR_BUFLEN && GuardPtr)
return -1;
}
}
mad_timer_add(&Timer,Frame.header.duration);
mad_synth_frame(&Synth,&Frame);
SynthPos = 0;
}
return 0;
mad_timer_add(&Timer, Frame.header.duration);
mad_synth_frame(&Synth, &Frame);
SynthPos = 0;
}
return 0;
}

40
source/sounds/OggDecoder.cpp
View File

@ -30,8 +30,8 @@
#include <gui/sounds/OggDecoder.hpp>
#include "fs/CFile.hpp"
static int ogg_read(void * punt, int bytes, int blocks, int *f) {
return ((CFile *) f)->read((uint8_t *) punt, bytes*blocks);
static int ogg_read(void *punt, int bytes, int blocks, int *f) {
return ((CFile *) f)->read((uint8_t *) punt, bytes * blocks);
}
static int ogg_seek(int *f, ogg_int64_t offset, int mode) {
@ -48,27 +48,27 @@ static long ogg_tell(int *f) {
}
static ov_callbacks callbacks = {
(size_t (*)(void *, size_t, size_t, void *)) ogg_read,
(int (*)(void *, ogg_int64_t, int)) ogg_seek,
(int (*)(void *)) ogg_close,
(long (*)(void *)) ogg_tell
(size_t (*)(void *, size_t, size_t, void *)) ogg_read,
(int (*)(void *, ogg_int64_t, int)) ogg_seek,
(int (*)(void *)) ogg_close,
(long (*)(void *)) ogg_tell
};
OggDecoder::OggDecoder(const char * filepath)
: SoundDecoder(filepath) {
OggDecoder::OggDecoder(const char *filepath)
: SoundDecoder(filepath) {
SoundType = SOUND_OGG;
if(!file_fd)
if (!file_fd)
return;
OpenFile();
}
OggDecoder::OggDecoder(const uint8_t * snd, int32_t len)
: SoundDecoder(snd, len) {
OggDecoder::OggDecoder(const uint8_t *snd, int32_t len)
: SoundDecoder(snd, len) {
SoundType = SOUND_OGG;
if(!file_fd)
if (!file_fd)
return;
OpenFile();
@ -76,10 +76,10 @@ OggDecoder::OggDecoder(const uint8_t * snd, int32_t len)
OggDecoder::~OggDecoder() {
ExitRequested = true;
while(Decoding)
while (Decoding)
OSSleepTicks(OSMicrosecondsToTicks(100));
if(file_fd)
if (file_fd)
ov_clear(&ogg_file);
}
@ -91,7 +91,7 @@ void OggDecoder::OpenFile() {
}
ogg_info = ov_info(&ogg_file, -1);
if(!ogg_info) {
if (!ogg_info) {
ov_clear(&ogg_file);
delete file_fd;
file_fd = NULL;
@ -103,7 +103,7 @@ void OggDecoder::OpenFile() {
}
int32_t OggDecoder::Rewind() {
if(!file_fd)
if (!file_fd)
return -1;
int32_t ret = ov_time_seek(&ogg_file, 0);
@ -113,15 +113,15 @@ int32_t OggDecoder::Rewind() {
return ret;
}
int32_t OggDecoder::Read(uint8_t * buffer, int32_t buffer_size, int32_t pos) {
if(!file_fd)
int32_t OggDecoder::Read(uint8_t *buffer, int32_t buffer_size, int32_t pos) {
if (!file_fd)
return -1;
int32_t bitstream = 0;
int32_t read = (int32_t) ov_read(&ogg_file, (char *) buffer, (int) buffer_size, (int *)&bitstream);
int32_t read = (int32_t) ov_read(&ogg_file, (char *) buffer, (int) buffer_size, (int *) &bitstream);
if(read > 0)
if (read > 0)
CurPos += read;
return read;

86
source/sounds/SoundDecoder.cpp
View File

@ -32,36 +32,36 @@ SoundDecoder::SoundDecoder() {
Init();
}
SoundDecoder::SoundDecoder(const std::string & filepath) {
SoundDecoder::SoundDecoder(const std::string &filepath) {
file_fd = new CFile(filepath, CFile::ReadOnly);
Init();
}
SoundDecoder::SoundDecoder(const uint8_t * buffer, int32_t size) {
SoundDecoder::SoundDecoder(const uint8_t *buffer, int32_t size) {
file_fd = new CFile(buffer, size);
Init();
}
SoundDecoder::~SoundDecoder() {
ExitRequested = true;
while(Decoding)
while (Decoding)
OSSleepTicks(OSMicrosecondsToTicks(1000));
//! lock unlock once to make sure it's really not decoding
Lock();
Unlock();
if(file_fd)
if (file_fd)
delete file_fd;
file_fd = NULL;
if(ResampleBuffer)
if (ResampleBuffer)
free(ResampleBuffer);
}
int32_t SoundDecoder::Seek(int32_t pos) {
CurPos = pos;
return file_fd->seek(CurPos, SEEK_SET);
CurPos = pos;
return file_fd->seek(CurPos, SEEK_SET);
}
void SoundDecoder::Init() {
@ -89,7 +89,7 @@ int32_t SoundDecoder::Rewind() {
return 0;
}
int32_t SoundDecoder::Read(uint8_t * buffer, int32_t buffer_size, int32_t pos) {
int32_t SoundDecoder::Read(uint8_t *buffer, int32_t buffer_size, int32_t pos) {
int32_t ret = file_fd->read(buffer, buffer_size);
CurPos += ret;
@ -97,13 +97,13 @@ int32_t SoundDecoder::Read(uint8_t * buffer, int32_t buffer_size, int32_t pos) {
}
void SoundDecoder::EnableUpsample(void) {
if( (ResampleBuffer == NULL)
&& IsStereo() && Is16Bit()
&& SampleRate != 32000
&& SampleRate != 48000) {
ResampleBuffer = (uint8_t*)memalign(32, SoundBlockSize);
ResampleRatio = ( FixedPointScale * SampleRate ) / 48000;
SoundBlockSize = ( SoundBlockSize * ResampleRatio ) / FixedPointScale;
if ((ResampleBuffer == NULL)
&& IsStereo() && Is16Bit()
&& SampleRate != 32000
&& SampleRate != 48000) {
ResampleBuffer = (uint8_t *) memalign(32, SoundBlockSize);
ResampleRatio = (FixedPointScale * SampleRate) / 48000;
SoundBlockSize = (SoundBlockSize * ResampleRatio) / FixedPointScale;
SoundBlockSize &= ~0x03;
// set new sample rate
SampleRate = 48000;
@ -113,19 +113,19 @@ void SoundDecoder::EnableUpsample(void) {
void SoundDecoder::Upsample(int16_t *src, int16_t *dst, uint32_t nr_src_samples, uint32_t nr_dst_samples) {
int32_t timer = 0;
for(uint32_t i = 0, n = 0; i < nr_dst_samples; i += 2) {
if((n+3) < nr_src_samples) {
for (uint32_t i = 0, n = 0; i < nr_dst_samples; i += 2) {
if ((n + 3) < nr_src_samples) {
// simple fixed point linear interpolation
dst[i] = src[n] + ( ((src[n+2] - src[n] ) * timer) >> FixedPointShift );
dst[i+1] = src[n+1] + ( ((src[n+3] - src[n+1]) * timer) >> FixedPointShift );
dst[i] = src[n] + (((src[n + 2] - src[n]) * timer) >> FixedPointShift);
dst[i + 1] = src[n + 1] + (((src[n + 3] - src[n + 1]) * timer) >> FixedPointShift);
} else {
dst[i] = src[n];
dst[i+1] = src[n+1];
dst[i] = src[n];
dst[i + 1] = src[n + 1];
}
timer += ResampleRatio;
if(timer >= (int32_t)FixedPointScale) {
if (timer >= (int32_t) FixedPointScale) {
n += 2;
timer -= FixedPointScale;
}
@ -133,35 +133,35 @@ void SoundDecoder::Upsample(int16_t *src, int16_t *dst, uint32_t nr_src_samples,
}
void SoundDecoder::Decode() {
if(!file_fd || ExitRequested || EndOfFile)
if (!file_fd || ExitRequested || EndOfFile)
return;
// check if we are not at the pre-last buffer (last buffer is playing)
uint16_t whichPlaying = SoundBuffer.Which();
if( ((whichPlaying == 0) && (whichLoad == SoundBuffer.Size()-2))
|| ((whichPlaying == 1) && (whichLoad == SoundBuffer.Size()-1))
|| (whichLoad == (whichPlaying-2))) {
if (((whichPlaying == 0) && (whichLoad == SoundBuffer.Size() - 2))
|| ((whichPlaying == 1) && (whichLoad == SoundBuffer.Size() - 1))
|| (whichLoad == (whichPlaying - 2))) {
return;
}
Decoding = true;
int32_t done = 0;
uint8_t * write_buf = SoundBuffer.GetBuffer(whichLoad);
if(!write_buf) {
int32_t done = 0;
uint8_t *write_buf = SoundBuffer.GetBuffer(whichLoad);
if (!write_buf) {
ExitRequested = true;
Decoding = false;
return;
}
if(ResampleTo48kHz && !ResampleBuffer)
if (ResampleTo48kHz && !ResampleBuffer)
EnableUpsample();
while(done < SoundBlockSize) {
int32_t ret = Read(&write_buf[done], SoundBlockSize-done, Tell());
while (done < SoundBlockSize) {
int32_t ret = Read(&write_buf[done], SoundBlockSize - done, Tell());
if(ret <= 0) {
if(Loop) {
if (ret <= 0) {
if (Loop) {
Rewind();
continue;
} else {
@ -173,36 +173,36 @@ void SoundDecoder::Decode() {
done += ret;
}
if(done > 0) {
if (done > 0) {
// check if we need to resample
if(ResampleBuffer && ResampleRatio) {
if (ResampleBuffer && ResampleRatio) {
memcpy(ResampleBuffer, write_buf, done);
int32_t src_samples = done >> 1;
int32_t dest_samples = ( src_samples * FixedPointScale ) / ResampleRatio;
int32_t dest_samples = (src_samples * FixedPointScale) / ResampleRatio;
dest_samples &= ~0x01;
Upsample((int16_t*)ResampleBuffer, (int16_t*)write_buf, src_samples, dest_samples);
Upsample((int16_t *) ResampleBuffer, (int16_t *) write_buf, src_samples, dest_samples);
done = dest_samples << 1;
}
//! TODO: remove this later and add STEREO support with two voices, for now we convert to MONO
if(IsStereo()) {
int16_t* monoBuf = (int16_t*)write_buf;
if (IsStereo()) {
int16_t *monoBuf = (int16_t *) write_buf;
done = done >> 1;
for(int32_t i = 0; i < done; i++)
for (int32_t i = 0; i < done; i++)
monoBuf[i] = monoBuf[i << 1];
}
DCFlushRange(write_buf, done);
SoundBuffer.SetBufferSize(whichLoad, done);
SoundBuffer.SetBufferReady(whichLoad, true);
if(++whichLoad >= SoundBuffer.Size())
if (++whichLoad >= SoundBuffer.Size())
whichLoad = 0;
}
// check if next in queue needs to be filled as well and do so
if(!SoundBuffer.IsBufferReady(whichLoad))
if (!SoundBuffer.IsBufferReady(whichLoad))
Decode();
Decoding = false;

210
source/sounds/SoundHandler.cpp
View File

@ -32,13 +32,13 @@
#include <gui/sounds/OggDecoder.hpp>
#include <sndcore2/core.h>
SoundHandler * SoundHandler::handlerInstance = NULL;
SoundHandler *SoundHandler::handlerInstance = NULL;
SoundHandler::SoundHandler()
: CThread(CThread::eAttributeAffCore1 | CThread::eAttributePinnedAff, 0, 0x8000) {
: CThread(CThread::eAttributeAffCore1 | CThread::eAttributePinnedAff, 0, 0x8000) {
Decoding = false;
ExitRequested = false;
for(uint32_t i = 0; i < MAX_DECODERS; ++i) {
for (uint32_t i = 0; i < MAX_DECODERS; ++i) {
DecoderList[i] = NULL;
voiceList[i] = NULL;
}
@ -46,7 +46,7 @@ SoundHandler::SoundHandler()
resumeThread();
//! wait for initialization
while(!isThreadSuspended())
while (!isThreadSuspended())
OSSleepTicks(OSMicrosecondsToTicks(1000));
}
@ -57,40 +57,40 @@ SoundHandler::~SoundHandler() {
ClearDecoderList();
}
void SoundHandler::AddDecoder(int32_t voice, const char * filepath) {
if(voice < 0 || voice >= MAX_DECODERS)
void SoundHandler::AddDecoder(int32_t voice, const char *filepath) {
if (voice < 0 || voice >= MAX_DECODERS)
return;
if(DecoderList[voice] != NULL)
if (DecoderList[voice] != NULL)
RemoveDecoder(voice);
DecoderList[voice] = GetSoundDecoder(filepath);
}
void SoundHandler::AddDecoder(int32_t voice, const uint8_t * snd, int32_t len) {
if(voice < 0 || voice >= MAX_DECODERS)
void SoundHandler::AddDecoder(int32_t voice, const uint8_t *snd, int32_t len) {
if (voice < 0 || voice >= MAX_DECODERS)
return;
if(DecoderList[voice] != NULL)
if (DecoderList[voice] != NULL)
RemoveDecoder(voice);
DecoderList[voice] = GetSoundDecoder(snd, len);
}
void SoundHandler::RemoveDecoder(int32_t voice) {
if(voice < 0 || voice >= MAX_DECODERS)
if (voice < 0 || voice >= MAX_DECODERS)
return;
if(DecoderList[voice] != NULL) {
if(voiceList[voice] && voiceList[voice]->getState() != Voice::STATE_STOPPED) {
if(voiceList[voice]->getState() != Voice::STATE_STOP)
if (DecoderList[voice] != NULL) {
if (voiceList[voice] && voiceList[voice]->getState() != Voice::STATE_STOPPED) {
if (voiceList[voice]->getState() != Voice::STATE_STOP)
voiceList[voice]->setState(Voice::STATE_STOP);
// it shouldn't take longer than 3 ms actually but we wait up to 20
// it shouldn't take longer than 3 ms actually but we wait up to 20
// on application quit the AX frame callback is not called anymore
// therefore this would end in endless loop if no timeout is defined
int timeOut = 20;
while(--timeOut && (voiceList[voice]->getState() != Voice::STATE_STOPPED))
while (--timeOut && (voiceList[voice]->getState() != Voice::STATE_STOPPED))
OSSleepTicks(OSMicrosecondsToTicks(1000));
}
SoundDecoder *decoder = DecoderList[voice];
@ -102,87 +102,87 @@ void SoundHandler::RemoveDecoder(int32_t voice) {
}
void SoundHandler::ClearDecoderList() {
for(uint32_t i = 0; i < MAX_DECODERS; ++i)
for (uint32_t i = 0; i < MAX_DECODERS; ++i)
RemoveDecoder(i);
}
static inline bool CheckMP3Signature(const uint8_t * buffer) {
static inline bool CheckMP3Signature(const uint8_t *buffer) {
const char MP3_Magic[][3] = {
{'I', 'D', '3'}, //'ID3'
{0xff, 0xfe}, //'MPEG ADTS, layer III, v1.0 [protected]', 'mp3', 'audio/mpeg'),
{0xff, 0xff}, //'MPEG ADTS, layer III, v1.0', 'mp3', 'audio/mpeg'),
{0xff, 0xfa}, //'MPEG ADTS, layer III, v1.0 [protected]', 'mp3', 'audio/mpeg'),
{0xff, 0xfb}, //'MPEG ADTS, layer III, v1.0', 'mp3', 'audio/mpeg'),
{0xff, 0xf2}, //'MPEG ADTS, layer III, v2.0 [protected]', 'mp3', 'audio/mpeg'),
{0xff, 0xf3}, //'MPEG ADTS, layer III, v2.0', 'mp3', 'audio/mpeg'),
{0xff, 0xf4}, //'MPEG ADTS, layer III, v2.0 [protected]', 'mp3', 'audio/mpeg'),
{0xff, 0xf5}, //'MPEG ADTS, layer III, v2.0', 'mp3', 'audio/mpeg'),
{0xff, 0xf6}, //'MPEG ADTS, layer III, v2.0 [protected]', 'mp3', 'audio/mpeg'),
{0xff, 0xf7}, //'MPEG ADTS, layer III, v2.0', 'mp3', 'audio/mpeg'),
{0xff, 0xe2}, //'MPEG ADTS, layer III, v2.5 [protected]', 'mp3', 'audio/mpeg'),
{0xff, 0xe3}, //'MPEG ADTS, layer III, v2.5', 'mp3', 'audio/mpeg'),
{'I', 'D', '3'}, //'ID3'
{0xff, 0xfe}, //'MPEG ADTS, layer III, v1.0 [protected]', 'mp3', 'audio/mpeg'),
{0xff, 0xff}, //'MPEG ADTS, layer III, v1.0', 'mp3', 'audio/mpeg'),
{0xff, 0xfa}, //'MPEG ADTS, layer III, v1.0 [protected]', 'mp3', 'audio/mpeg'),
{0xff, 0xfb}, //'MPEG ADTS, layer III, v1.0', 'mp3', 'audio/mpeg'),
{0xff, 0xf2}, //'MPEG ADTS, layer III, v2.0 [protected]', 'mp3', 'audio/mpeg'),
{0xff, 0xf3}, //'MPEG ADTS, layer III, v2.0', 'mp3', 'audio/mpeg'),
{0xff, 0xf4}, //'MPEG ADTS, layer III, v2.0 [protected]', 'mp3', 'audio/mpeg'),
{0xff, 0xf5}, //'MPEG ADTS, layer III, v2.0', 'mp3', 'audio/mpeg'),
{0xff, 0xf6}, //'MPEG ADTS, layer III, v2.0 [protected]', 'mp3', 'audio/mpeg'),
{0xff, 0xf7}, //'MPEG ADTS, layer III, v2.0', 'mp3', 'audio/mpeg'),
{0xff, 0xe2}, //'MPEG ADTS, layer III, v2.5 [protected]', 'mp3', 'audio/mpeg'),
{0xff, 0xe3}, //'MPEG ADTS, layer III, v2.5', 'mp3', 'audio/mpeg'),
};
if(buffer[0] == MP3_Magic[0][0] && buffer[1] == MP3_Magic[0][1] &&
buffer[2] == MP3_Magic[0][2]) {
if (buffer[0] == MP3_Magic[0][0] && buffer[1] == MP3_Magic[0][1] &&
buffer[2] == MP3_Magic[0][2]) {
return true;
}
for(int32_t i = 1; i < 13; i++) {
if(buffer[0] == MP3_Magic[i][0] && buffer[1] == MP3_Magic[i][1])
for (int32_t i = 1; i < 13; i++) {
if (buffer[0] == MP3_Magic[i][0] && buffer[1] == MP3_Magic[i][1])
return true;
}
return false;
}
SoundDecoder * SoundHandler::GetSoundDecoder(const char * filepath) {
SoundDecoder *SoundHandler::GetSoundDecoder(const char *filepath) {
uint32_t magic;
CFile f(filepath, CFile::ReadOnly);
if(f.size() == 0)
if (f.size() == 0)
return NULL;
do {
f.read((uint8_t *) &magic, 1);
} while(((uint8_t *) &magic)[0] == 0 && f.tell() < f.size());
} while (((uint8_t *) &magic)[0] == 0 && f.tell() < f.size());
if(f.tell() == f.size())
if (f.tell() == f.size())
return NULL;
f.seek(f.tell()-1, SEEK_SET);
f.seek(f.tell() - 1, SEEK_SET);
f.read((uint8_t *) &magic, 4);
f.close();
if(magic == 0x4f676753) { // 'OggS'
if (magic == 0x4f676753) { // 'OggS'
return new OggDecoder(filepath);
} else if(magic == 0x52494646) { // 'RIFF'
} else if (magic == 0x52494646) { // 'RIFF'
return new WavDecoder(filepath);
} else if(CheckMP3Signature((uint8_t *) &magic) == true) {
} else if (CheckMP3Signature((uint8_t *) &magic) == true) {
return new Mp3Decoder(filepath);
}
return new SoundDecoder(filepath);
}
SoundDecoder * SoundHandler::GetSoundDecoder(const uint8_t * sound, int32_t length) {
const uint8_t * check = sound;
SoundDecoder *SoundHandler::GetSoundDecoder(const uint8_t *sound, int32_t length) {
const uint8_t *check = sound;
int32_t counter = 0;
while(check[0] == 0 && counter < length) {
while (check[0] == 0 && counter < length) {
check++;
counter++;
}
if(counter >= length)
if (counter >= length)
return NULL;
uint32_t * magic = (uint32_t *) check;
uint32_t *magic = (uint32_t *) check;
if(magic[0] == 0x4f676753) { // 'OggS'
if (magic[0] == 0x4f676753) { // 'OggS'
return new OggDecoder(sound, length);
} else if(magic[0] == 0x52494646) { // 'RIFF'
} else if (magic[0] == 0x52494646) { // 'RIFF'
return new WavDecoder(sound, length);
} else if(CheckMP3Signature(check) == true) {
} else if (CheckMP3Signature(check) == true) {
return new Mp3Decoder(sound, length);
}
@ -211,8 +211,8 @@ void SoundHandler::executeThread() {
// The problem with last voice on 500 was caused by it having priority 0
// We would need to change this priority distribution if for some reason
// we would need MAX_DECODERS > Voice::PRIO_MAX
for(uint32_t i = 0; i < MAX_DECODERS; ++i) {
int32_t priority = (MAX_DECODERS - i) * Voice::PRIO_MAX / MAX_DECODERS;
for (uint32_t i = 0; i < MAX_DECODERS; ++i) {
int32_t priority = (MAX_DECODERS - i) * Voice::PRIO_MAX / MAX_DECODERS;
voiceList[i] = new Voice(priority); // allocate voice 0 with highest priority
}
@ -223,28 +223,28 @@ void SoundHandler::executeThread() {
while (!ExitRequested) {
suspendThread();
for(i = 0; i < MAX_DECODERS; ++i) {
if(DecoderList[i] == NULL)
for (i = 0; i < MAX_DECODERS; ++i) {
if (DecoderList[i] == NULL)
continue;
Decoding = true;
if(DecoderList[i])
if (DecoderList[i])
DecoderList[i]->Lock();
if(DecoderList[i])
if (DecoderList[i])
DecoderList[i]->Decode();
if(DecoderList[i])
if (DecoderList[i])
DecoderList[i]->Unlock();
}
Decoding = false;
}
for(uint32_t i = 0; i < MAX_DECODERS; ++i)
for (uint32_t i = 0; i < MAX_DECODERS; ++i)
voiceList[i]->stop();
AXRegisterAppFrameCallback(NULL);
AXQuit();
for(uint32_t i = 0; i < MAX_DECODERS; ++i) {
for (uint32_t i = 0; i < MAX_DECODERS; ++i) {
delete voiceList[i];
voiceList[i] = NULL;
}
@ -255,59 +255,59 @@ void SoundHandler::axFrameCallback(void) {
Voice *voice = handlerInstance->getVoice(i);
switch (voice->getState()) {
default:
case Voice::STATE_STOPPED:
break;
default:
case Voice::STATE_STOPPED:
break;
case Voice::STATE_START: {
SoundDecoder * decoder = handlerInstance->getDecoder(i);
decoder->Lock();
if(decoder->IsBufferReady()) {
const uint8_t *buffer = decoder->GetBuffer();
const uint32_t bufferSize = decoder->GetBufferSize();
decoder->LoadNext();
const uint8_t *nextBuffer = NULL;
uint32_t nextBufferSize = 0;
if(decoder->IsBufferReady()) {
nextBuffer = decoder->GetBuffer();
nextBufferSize = decoder->GetBufferSize();
case Voice::STATE_START: {
SoundDecoder *decoder = handlerInstance->getDecoder(i);
decoder->Lock();
if (decoder->IsBufferReady()) {
const uint8_t *buffer = decoder->GetBuffer();
const uint32_t bufferSize = decoder->GetBufferSize();
decoder->LoadNext();
}
voice->play(buffer, bufferSize, nextBuffer, nextBufferSize, decoder->GetFormat() & 0xff, decoder->GetSampleRate());
const uint8_t *nextBuffer = NULL;
uint32_t nextBufferSize = 0;
handlerInstance->ThreadSignal();
voice->setState(Voice::STATE_PLAYING);
}
decoder->Unlock();
break;
}
case Voice::STATE_PLAYING:
if(voice->getInternState() == 1) {
if(voice->isBufferSwitched()) {
SoundDecoder * decoder = handlerInstance->getDecoder(i);
decoder->Lock();
if(decoder->IsBufferReady()) {
voice->setNextBuffer(decoder->GetBuffer(), decoder->GetBufferSize());
if (decoder->IsBufferReady()) {
nextBuffer = decoder->GetBuffer();
nextBufferSize = decoder->GetBufferSize();
decoder->LoadNext();
handlerInstance->ThreadSignal();
} else if(decoder->IsEOF()) {
voice->setState(Voice::STATE_STOP);
}
decoder->Unlock();
voice->play(buffer, bufferSize, nextBuffer, nextBufferSize, decoder->GetFormat() & 0xff, decoder->GetSampleRate());
handlerInstance->ThreadSignal();
voice->setState(Voice::STATE_PLAYING);
}
} else {
voice->setState(Voice::STATE_STOPPED);
decoder->Unlock();
break;
}
break;
case Voice::STATE_STOP:
if(voice->getInternState() != 0)
voice->stop();
voice->setState(Voice::STATE_STOPPED);
break;
case Voice::STATE_PLAYING:
if (voice->getInternState() == 1) {
if (voice->isBufferSwitched()) {
SoundDecoder *decoder = handlerInstance->getDecoder(i);
decoder->Lock();
if (decoder->IsBufferReady()) {
voice->setNextBuffer(decoder->GetBuffer(), decoder->GetBufferSize());
decoder->LoadNext();
handlerInstance->ThreadSignal();
} else if (decoder->IsEOF()) {
voice->setState(Voice::STATE_STOP);
}
decoder->Unlock();
}
} else {
voice->setState(Voice::STATE_STOPPED);
}
break;
case Voice::STATE_STOP:
if (voice->getInternState() != 0)
voice->stop();
voice->setState(Voice::STATE_STOPPED);
break;
}
}
}

42
source/sounds/WavDecoder.cpp
View File

@ -28,25 +28,25 @@
#include "fs/CFile.hpp"
#include "utils/utils.h"
WavDecoder::WavDecoder(const char * filepath)
: SoundDecoder(filepath) {
WavDecoder::WavDecoder(const char *filepath)
: SoundDecoder(filepath) {
SoundType = SOUND_WAV;
SampleRate = 48000;
Format = CHANNELS_STEREO | FORMAT_PCM_16_BIT;
if(!file_fd)
if (!file_fd)
return;
OpenFile();
}
WavDecoder::WavDecoder(const uint8_t * snd, int32_t len)
: SoundDecoder(snd, len) {
WavDecoder::WavDecoder(const uint8_t *snd, int32_t len)
: SoundDecoder(snd, len) {
SoundType = SOUND_WAV;
SampleRate = 48000;
Format = CHANNELS_STEREO | FORMAT_PCM_16_BIT;
if(!file_fd)
if (!file_fd)
return;
OpenFile();
@ -68,24 +68,24 @@ void WavDecoder::OpenFile() {
if (Header.magicRIFF != 0x52494646) { // 'RIFF'
CloseFile();
return;
} else if(Header.magicWAVE != 0x57415645) { // 'WAVE'
} else if (Header.magicWAVE != 0x57415645) { // 'WAVE'
CloseFile();
return;
} else if(FmtChunk.magicFMT != 0x666d7420) { // 'fmt '
} else if (FmtChunk.magicFMT != 0x666d7420) { // 'fmt '
CloseFile();
return;
}
DataOffset = sizeof(SWaveHdr)+le32(FmtChunk.size)+8;
DataOffset = sizeof(SWaveHdr) + le32(FmtChunk.size) + 8;
file_fd->seek(DataOffset, SEEK_SET);
SWaveChunk DataChunk;
file_fd->read((uint8_t *) &DataChunk, sizeof(SWaveChunk));
while(DataChunk.magicDATA != 0x64617461) { // 'data'
DataOffset += 8+le32(DataChunk.size);
while (DataChunk.magicDATA != 0x64617461) { // 'data'
DataOffset += 8 + le32(DataChunk.size);
file_fd->seek(DataOffset, SEEK_SET);
int32_t ret = file_fd->read((uint8_t *) &DataChunk, sizeof(SWaveChunk));
if(ret <= 0) {
if (ret <= 0) {
CloseFile();
return;
}
@ -107,30 +107,30 @@ void WavDecoder::OpenFile() {
}
void WavDecoder::CloseFile() {
if(file_fd)
if (file_fd)
delete file_fd;
file_fd = NULL;
}
int32_t WavDecoder::Read(uint8_t * buffer, int32_t buffer_size, int32_t pos) {
if(!file_fd)
int32_t WavDecoder::Read(uint8_t *buffer, int32_t buffer_size, int32_t pos) {
if (!file_fd)
return -1;
if(CurPos >= (int32_t) DataSize)
if (CurPos >= (int32_t) DataSize)
return 0;
file_fd->seek(DataOffset+CurPos, SEEK_SET);
file_fd->seek(DataOffset + CurPos, SEEK_SET);
if(buffer_size > (int32_t) DataSize-CurPos)
buffer_size = DataSize-CurPos;
if (buffer_size > (int32_t) DataSize - CurPos)
buffer_size = DataSize - CurPos;
int32_t read = file_fd->read(buffer, buffer_size);
if(read > 0) {
if (read > 0) {
if (Is16Bit) {
read &= ~0x0001;
for (uint32_t i = 0; i < (uint32_t) (read / sizeof (uint16_t)); ++i)
for (uint32_t i = 0; i < (uint32_t) (read / sizeof(uint16_t)); ++i)
((uint16_t *) buffer)[i] = le16(((uint16_t *) buffer)[i]);
}
CurPos += read;

18
source/system/memory.c
View File

@ -39,30 +39,30 @@ static MEMHeapHandle mem1_heap = NULL;
static MEMHeapHandle bucket_heap = NULL;
void libgui_memoryInitialize(void) {
if(!mem1_heap) {
if (!mem1_heap) {
MEMHeapHandle mem1_heap_handle = MEMGetBaseHeapHandle(MEMORY_ARENA_1);
uint32_t mem1_allocatable_size = MEMGetAllocatableSizeForFrmHeapEx(mem1_heap_handle, 4);
void *mem1_memory = MEMAllocFromFrmHeapEx(mem1_heap_handle, mem1_allocatable_size, 4);
if(mem1_memory)
if (mem1_memory)
mem1_heap = MEMCreateExpHeapEx(mem1_memory, mem1_allocatable_size, 0);
}
if(!bucket_heap) {
if (!bucket_heap) {
MEMHeapHandle bucket_heap_handle = MEMGetBaseHeapHandle(MEMORY_ARENA_FG_BUCKET);
uint32_t bucket_allocatable_size = MEMGetAllocatableSizeForFrmHeapEx(bucket_heap_handle, 4);
void *bucket_memory = MEMAllocFromFrmHeapEx(bucket_heap_handle, bucket_allocatable_size, 4);
if(bucket_memory)
if (bucket_memory)
bucket_heap = MEMCreateExpHeapEx(bucket_memory, bucket_allocatable_size, 0);
}
}
void libgui_memoryRelease(void) {
if(mem1_heap) {
if (mem1_heap) {
MEMDestroyExpHeap(mem1_heap);
MEMFreeToFrmHeap(MEMGetBaseHeapHandle(MEMORY_ARENA_1), 3);
mem1_heap = NULL;
}
if(bucket_heap) {
if (bucket_heap) {
MEMDestroyExpHeap(bucket_heap);
MEMFreeToFrmHeap(MEMGetBaseHeapHandle(MEMORY_ARENA_FG_BUCKET), 3);
bucket_heap = NULL;
@ -156,7 +156,7 @@ void *__wrap__realloc_r(struct _reent *r, void *p, size_t size)
//!-------------------------------------------------------------------------------------------
//! some wrappers
//!-------------------------------------------------------------------------------------------
void * MEM2_alloc(uint32_t size, uint32_t align) {
void *MEM2_alloc(uint32_t size, uint32_t align) {
return memalign(align, size);
}
@ -164,7 +164,7 @@ void MEM2_free(void *ptr) {
free(ptr);
}
void * MEM1_alloc(uint32_t size, uint32_t align) {
void *MEM1_alloc(uint32_t size, uint32_t align) {
if (align < 4)
align = 4;
return MEMAllocFromExpHeapEx(mem1_heap, size, align);
@ -174,7 +174,7 @@ void MEM1_free(void *ptr) {
MEMFreeToExpHeap(mem1_heap, ptr);
}
void * MEMBucket_alloc(uint32_t size, uint32_t align) {
void *MEMBucket_alloc(uint32_t size, uint32_t align) {
if (align < 4)
align = 4;
return MEMAllocFromExpHeapEx(bucket_heap, size, align);

14
source/utils/utils.h
View File

@ -7,12 +7,12 @@
extern "C" {
#endif
#define LIMIT(x, min, max) \
({ \
typeof( x ) _x = x; \
typeof( min ) _min = min; \
typeof( max ) _max = max; \
( ( ( _x ) < ( _min ) ) ? ( _min ) : ( ( _x ) > ( _max ) ) ? ( _max) : ( _x ) ); \
#define LIMIT(x, min, max) \
({ \
typeof( x ) _x = x; \
typeof( min ) _min = min; \
typeof( max ) _max = max; \
( ( ( _x ) < ( _min ) ) ? ( _min ) : ( ( _x ) > ( _max ) ) ? ( _max) : ( _x ) ); \
})
#define DegToRad(a) ( (a) * 0.01745329252f )
@ -26,7 +26,7 @@ extern "C" {
#define le64(i) ((((uint64_t)le32((i) & 0xFFFFFFFFLL)) << 32) | ((uint64_t)le32(((i) & 0xFFFFFFFF00000000LL) >> 32)))
//Needs to have log_init() called beforehand.
void dumpHex(const void* data, size_t size);
void dumpHex(const void *data, size_t size);
#ifdef __cplusplus
}

84
source/video/CVideo.cpp
View File

@ -35,7 +35,7 @@ CVideo::CVideo(int32_t forceTvScanMode, int32_t forceDrcScanMode) {
//! initialize GX2 command buffer
uint32_t gx2_init_attributes[9];
gx2_init_attributes[0] = GX2_INIT_CMD_BUF_BASE;
gx2_init_attributes[1] = (uint32_t)gx2CommandBuffer;
gx2_init_attributes[1] = (uint32_t) gx2CommandBuffer;
gx2_init_attributes[2] = GX2_INIT_CMD_BUF_POOL_SIZE;
gx2_init_attributes[3] = GX2_COMMAND_BUFFER_SIZE;
gx2_init_attributes[4] = GX2_INIT_ARGC;
@ -48,56 +48,56 @@ CVideo::CVideo(int32_t forceTvScanMode, int32_t forceDrcScanMode) {
uint32_t scanBufferSize = 0;
uint32_t scaleNeeded = 0;
int32_t tvScanMode = ((forceTvScanMode >= 0) ? forceTvScanMode : (int32_t)GX2GetSystemTVScanMode());
int32_t drcScanMode = ((forceDrcScanMode >= 0) ? forceDrcScanMode : (int32_t)GX2GetSystemDRCScanMode());
int32_t tvScanMode = ((forceTvScanMode >= 0) ? forceTvScanMode : (int32_t) GX2GetSystemTVScanMode());
int32_t drcScanMode = ((forceDrcScanMode >= 0) ? forceDrcScanMode : (int32_t) GX2GetSystemDRCScanMode());
int32_t tvRenderMode;
uint32_t tvWidth = 0;
uint32_t tvHeight = 0;
switch(tvScanMode) {
case GX2_TV_SCAN_MODE_480I:
case GX2_TV_SCAN_MODE_480P:
tvWidth = 854;
tvHeight = 480;
tvRenderMode = GX2_TV_RENDER_MODE_WIDE_480P;
break;
case GX2_TV_SCAN_MODE_1080I:
case GX2_TV_SCAN_MODE_1080P:
tvWidth = 1920;
tvHeight = 1080;
tvRenderMode = GX2_TV_RENDER_MODE_WIDE_1080P;
break;
case GX2_TV_SCAN_MODE_720P:
default:
tvWidth = 1280;
tvHeight = 720;
tvRenderMode = GX2_TV_RENDER_MODE_WIDE_720P;
break;
switch (tvScanMode) {
case GX2_TV_SCAN_MODE_480I:
case GX2_TV_SCAN_MODE_480P:
tvWidth = 854;
tvHeight = 480;
tvRenderMode = GX2_TV_RENDER_MODE_WIDE_480P;
break;
case GX2_TV_SCAN_MODE_1080I:
case GX2_TV_SCAN_MODE_1080P:
tvWidth = 1920;
tvHeight = 1080;
tvRenderMode = GX2_TV_RENDER_MODE_WIDE_1080P;
break;
case GX2_TV_SCAN_MODE_720P:
default:
tvWidth = 1280;
tvHeight = 720;
tvRenderMode = GX2_TV_RENDER_MODE_WIDE_720P;
break;
}
int32_t tvAAMode = GX2_AA_MODE1X;
int32_t drcAAMode = GX2_AA_MODE4X;
//! calculate the scale factor for later texture resize
widthScaleFactor = 1.0f / (float)tvWidth;
heightScaleFactor = 1.0f / (float)tvHeight;
widthScaleFactor = 1.0f / (float) tvWidth;
heightScaleFactor = 1.0f / (float) tvHeight;
depthScaleFactor = widthScaleFactor;
//! calculate the size needed for the TV scan buffer and allocate the buffer from bucket memory
GX2CalcTVSize((GX2TVRenderMode)tvRenderMode, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, GX2_BUFFERING_MODE_DOUBLE, &scanBufferSize, &scaleNeeded);
GX2CalcTVSize((GX2TVRenderMode) tvRenderMode, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, GX2_BUFFERING_MODE_DOUBLE, &scanBufferSize, &scaleNeeded);
tvScanBuffer = MEMBucket_alloc(scanBufferSize, GX2_SCAN_BUFFER_ALIGNMENT);
GX2Invalidate(GX2_INVALIDATE_MODE_CPU, tvScanBuffer, scanBufferSize);
GX2SetTVBuffer(tvScanBuffer, scanBufferSize, (GX2TVRenderMode)tvRenderMode, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, GX2_BUFFERING_MODE_DOUBLE);
GX2SetTVBuffer(tvScanBuffer, scanBufferSize, (GX2TVRenderMode) tvRenderMode, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, GX2_BUFFERING_MODE_DOUBLE);
//! calculate the size needed for the DRC scan buffer and allocate the buffer from bucket memory
GX2CalcDRCSize((GX2DrcRenderMode)drcScanMode, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, GX2_BUFFERING_MODE_DOUBLE, &scanBufferSize, &scaleNeeded);
GX2CalcDRCSize((GX2DrcRenderMode) drcScanMode, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, GX2_BUFFERING_MODE_DOUBLE, &scanBufferSize, &scaleNeeded);
drcScanBuffer = MEMBucket_alloc(scanBufferSize, GX2_SCAN_BUFFER_ALIGNMENT);
GX2Invalidate(GX2_INVALIDATE_MODE_CPU, drcScanBuffer, scanBufferSize);
GX2SetDRCBuffer(drcScanBuffer, scanBufferSize, (GX2DrcRenderMode)drcScanMode, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, GX2_BUFFERING_MODE_DOUBLE);
GX2SetDRCBuffer(drcScanBuffer, scanBufferSize, (GX2DrcRenderMode) drcScanMode, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, GX2_BUFFERING_MODE_DOUBLE);
//! Setup color buffer for TV rendering
GX2InitColorBuffer(&tvColorBuffer, GX2_SURFACE_DIM_TEXTURE_2D, tvWidth, tvHeight, 1, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, (GX2AAMode)tvAAMode);
GX2InitColorBuffer(&tvColorBuffer, GX2_SURFACE_DIM_TEXTURE_2D, tvWidth, tvHeight, 1, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, (GX2AAMode) tvAAMode);
tvColorBuffer.surface.image = MEM1_alloc(tvColorBuffer.surface.imageSize, tvColorBuffer.surface.alignment);
GX2Invalidate(GX2_INVALIDATE_MODE_CPU, tvColorBuffer.surface.image, tvColorBuffer.surface.imageSize);
@ -106,7 +106,7 @@ CVideo::CVideo(int32_t forceTvScanMode, int32_t forceDrcScanMode) {
//! Setup TV depth buffer (can be the same for both if rendered one after another)
uint32_t size, align;
GX2InitDepthBuffer(&tvDepthBuffer, GX2_SURFACE_DIM_TEXTURE_2D, tvColorBuffer.surface.width, tvColorBuffer.surface.height, 1, GX2_SURFACE_FORMAT_FLOAT_R32, (GX2AAMode)tvAAMode);
GX2InitDepthBuffer(&tvDepthBuffer, GX2_SURFACE_DIM_TEXTURE_2D, tvColorBuffer.surface.width, tvColorBuffer.surface.height, 1, GX2_SURFACE_FORMAT_FLOAT_R32, (GX2AAMode) tvAAMode);
tvDepthBuffer.surface.image = MEM1_alloc(tvDepthBuffer.surface.imageSize, tvDepthBuffer.surface.alignment);
GX2Invalidate(GX2_INVALIDATE_MODE_CPU, tvDepthBuffer.surface.image, tvDepthBuffer.surface.imageSize);
@ -117,12 +117,12 @@ CVideo::CVideo(int32_t forceTvScanMode, int32_t forceDrcScanMode) {
GX2InitDepthBufferHiZEnable(&tvDepthBuffer, GX2_ENABLE);
//! Setup color buffer for DRC rendering
GX2InitColorBuffer(&drcColorBuffer, GX2_SURFACE_DIM_TEXTURE_2D, 854, 480, 1, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, (GX2AAMode)drcAAMode);
GX2InitColorBuffer(&drcColorBuffer, GX2_SURFACE_DIM_TEXTURE_2D, 854, 480, 1, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, (GX2AAMode) drcAAMode);
drcColorBuffer.surface.image = MEM1_alloc(drcColorBuffer.surface.imageSize, drcColorBuffer.surface.alignment);
GX2Invalidate(GX2_INVALIDATE_MODE_CPU, drcColorBuffer.surface.image, drcColorBuffer.surface.imageSize);
//! Setup DRC depth buffer (can be the same for both if rendered one after another)
GX2InitDepthBuffer(&drcDepthBuffer, GX2_SURFACE_DIM_TEXTURE_2D, drcColorBuffer.surface.width, drcColorBuffer.surface.height, 1, GX2_SURFACE_FORMAT_FLOAT_R32, (GX2AAMode)drcAAMode);
GX2InitDepthBuffer(&drcDepthBuffer, GX2_SURFACE_DIM_TEXTURE_2D, drcColorBuffer.surface.width, drcColorBuffer.surface.height, 1, GX2_SURFACE_FORMAT_FLOAT_R32, (GX2AAMode) drcAAMode);
drcDepthBuffer.surface.image = MEM1_alloc(drcDepthBuffer.surface.imageSize, drcDepthBuffer.surface.alignment);
GX2Invalidate(GX2_INVALIDATE_MODE_CPU, drcDepthBuffer.surface.image, drcDepthBuffer.surface.imageSize);
@ -138,7 +138,7 @@ CVideo::CVideo(int32_t forceTvScanMode, int32_t forceDrcScanMode) {
uint32_t auxSize, auxAlign;
GX2CalcColorBufferAuxInfo(&tvColorBuffer, &auxSize, &auxAlign);
tvColorBuffer.aaBuffer = MEM1_alloc(auxSize, auxAlign);
if(!tvColorBuffer.aaBuffer)
if (!tvColorBuffer.aaBuffer)
tvColorBuffer.aaBuffer = MEM2_alloc(auxSize, auxAlign);
tvColorBuffer.aaSize = auxSize;
@ -150,7 +150,7 @@ CVideo::CVideo(int32_t forceTvScanMode, int32_t forceDrcScanMode) {
uint32_t auxSize, auxAlign;
GX2CalcColorBufferAuxInfo(&drcColorBuffer, &auxSize, &auxAlign);
drcColorBuffer.aaBuffer = MEM1_alloc(auxSize, auxAlign);
if(!drcColorBuffer.aaBuffer)
if (!drcColorBuffer.aaBuffer)
drcColorBuffer.aaBuffer = MEM2_alloc(auxSize, auxAlign);
drcColorBuffer.aaSize = auxSize;
memset(drcColorBuffer.aaBuffer, GX2_AA_BUFFER_CLEAR_VALUE, auxSize);
@ -158,11 +158,11 @@ CVideo::CVideo(int32_t forceTvScanMode, int32_t forceDrcScanMode) {
}
//! allocate memory and setup context state TV
tvContextState = (GX2ContextState*)MEM2_alloc(sizeof(GX2ContextState), GX2_CONTEXT_STATE_ALIGNMENT);
tvContextState = (GX2ContextState *) MEM2_alloc(sizeof(GX2ContextState), GX2_CONTEXT_STATE_ALIGNMENT);
GX2SetupContextStateEx(tvContextState, GX2_TRUE);
//! allocate memory and setup context state DRC
drcContextState = (GX2ContextState*)MEM2_alloc(sizeof(GX2ContextState), GX2_CONTEXT_STATE_ALIGNMENT);
drcContextState = (GX2ContextState *) MEM2_alloc(sizeof(GX2ContextState), GX2_CONTEXT_STATE_ALIGNMENT);
GX2SetupContextStateEx(drcContextState, GX2_TRUE);
//! set initial context state and render buffers
@ -223,14 +223,14 @@ CVideo::~CVideo() {
MEM2_free(tvContextState);
MEM2_free(drcContextState);
//! free aux buffer
if(tvColorBuffer.aaBuffer) {
if(((uint32_t)tvColorBuffer.aaBuffer & 0xF0000000) == 0xF0000000)
if (tvColorBuffer.aaBuffer) {
if (((uint32_t) tvColorBuffer.aaBuffer & 0xF0000000) == 0xF0000000)
MEM1_free(tvColorBuffer.aaBuffer);
else
MEM2_free(tvColorBuffer.aaBuffer);
}
if(drcColorBuffer.aaBuffer) {
if(((uint32_t)drcColorBuffer.aaBuffer & 0xF0000000) == 0xF0000000)
if (drcColorBuffer.aaBuffer) {
if (((uint32_t) drcColorBuffer.aaBuffer & 0xF0000000) == 0xF0000000)
MEM1_free(drcColorBuffer.aaBuffer);
else
MEM2_free(drcColorBuffer.aaBuffer);
@ -243,11 +243,11 @@ CVideo::~CVideo() {
Texture2DShader::destroyInstance();
}
void CVideo::renderFXAA(const GX2Texture * texture, const GX2Sampler *sampler) {
void CVideo::renderFXAA(const GX2Texture *texture, const GX2Sampler *sampler) {
resolution[0] = texture->surface.width;
resolution[1] = texture->surface.height;
GX2Invalidate((GX2InvalidateMode)(GX2_INVALIDATE_MODE_COLOR_BUFFER | GX2_INVALIDATE_MODE_TEXTURE), texture->surface.image, texture->surface.imageSize);
GX2Invalidate((GX2InvalidateMode) (GX2_INVALIDATE_MODE_COLOR_BUFFER | GX2_INVALIDATE_MODE_TEXTURE), texture->surface.image, texture->surface.imageSize);
GX2SetDepthOnlyControl(GX2_ENABLE, GX2_ENABLE, GX2_COMPARE_FUNC_ALWAYS);
FXAAShader::instance()->setShaders();

24
source/video/CursorDrawer.cpp
View File

@ -38,41 +38,41 @@ CursorDrawer::~CursorDrawer() {
Shader3D::destroyInstance();
ShaderFractalColor::destroyInstance();
Texture2DShader::destroyInstance();
if(this->colorVtxs) {
if (this->colorVtxs) {
free(this->colorVtxs);
this->colorVtxs = NULL;
}
}
void CursorDrawer::init_colorVtxs() {
if(!this->colorVtxs) {
this->colorVtxs = (uint8_t*)memalign(0x40, sizeof(uint8_t) * 16);
if(this->colorVtxs == NULL) return;
if (!this->colorVtxs) {
this->colorVtxs = (uint8_t *) memalign(0x40, sizeof(uint8_t) * 16);
if (this->colorVtxs == NULL) return;
}
memset(this->colorVtxs,0xFF,16*sizeof(uint8_t));
memset(this->colorVtxs, 0xFF, 16 * sizeof(uint8_t));
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, this->colorVtxs, 16 * sizeof(uint8_t));
}
// Could be improved. It be more generic.
void CursorDrawer::draw_Cursor(float x,float y) {
if(this->colorVtxs == NULL) {
void CursorDrawer::draw_Cursor(float x, float y) {
if (this->colorVtxs == NULL) {
init_colorVtxs();
return;
}
float widthScaleFactor = 1.0f / (float)1280;
float heightScaleFactor = 1.0f / (float)720;
float widthScaleFactor = 1.0f / (float) 1280;
float heightScaleFactor = 1.0f / (float) 720;
int32_t width = 20;
glm::vec3 positionOffsets = glm::vec3(0.0f);
positionOffsets[0] = (x-((1280)/2)+(width/2)) * widthScaleFactor * 2.0f;
positionOffsets[1] = -(y-((720)/2)+(width/2)) * heightScaleFactor * 2.0f;
positionOffsets[0] = (x - ((1280) / 2) + (width / 2)) * widthScaleFactor * 2.0f;
positionOffsets[1] = -(y - ((720) / 2) + (width / 2)) * heightScaleFactor * 2.0f;
glm::vec3 scale(width*widthScaleFactor,width*heightScaleFactor,1.0f);
glm::vec3 scale(width * widthScaleFactor, width * heightScaleFactor, 1.0f);
ColorShader::instance()->setShaders();
ColorShader::instance()->setAttributeBuffer(this->colorVtxs, NULL, 4);

182
source/video/shaders/ColorShader.cpp
View File

@ -19,102 +19,102 @@
#include <gui/video/shaders/ColorShader.h>
static const uint32_t cpVertexShaderProgram[] = {
0x00000000,0x00008009,0x20000000,0x000078a0,
0x3c200000,0x88060094,0x00c00000,0x88062014,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00a11f00,0xfc00620f,0x02490001,0x80000040,
0xfd041f80,0x900c0060,0x83f9223e,0x0000803f,
0xfe282001,0x10000040,0xfe001f80,0x00080060,
0xfeac9f80,0xfd00624f,0xdb0f49c0,0xdb0fc940,
0xfea81f80,0x9000e02f,0x83f9223e,0x00000000,
0xfe041f80,0x00370000,0xffa01f00,0x80000000,
0xff101f00,0x800c0020,0x7f041f80,0x80370000,
0x0000103f,0x00000000,0x02c51f00,0x80000000,
0xfea41f00,0x80000020,0xffa09f00,0x80000040,
0xff001f80,0x800c0060,0x398ee33f,0x0000103f,
0x02c41f00,0x9000e00f,0x02c59f01,0x80000020,
0xfea81f00,0x80000040,0x02c19f80,0x9000e06f,
0x398ee33f,0x00000000,0x02c11f01,0x80000000,
0x02c49f80,0x80000060,0x02e08f01,0xfe0c620f,
0x02c01f80,0x7f00622f,0xfe242000,0x10000000,
0xfe20a080,0x10000020,0xf2178647,0x49c0e9fb,
0xfbbdb2ab,0x768ac733
0x00000000, 0x00008009, 0x20000000, 0x000078a0,
0x3c200000, 0x88060094, 0x00c00000, 0x88062014,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00a11f00, 0xfc00620f, 0x02490001, 0x80000040,
0xfd041f80, 0x900c0060, 0x83f9223e, 0x0000803f,
0xfe282001, 0x10000040, 0xfe001f80, 0x00080060,
0xfeac9f80, 0xfd00624f, 0xdb0f49c0, 0xdb0fc940,
0xfea81f80, 0x9000e02f, 0x83f9223e, 0x00000000,
0xfe041f80, 0x00370000, 0xffa01f00, 0x80000000,
0xff101f00, 0x800c0020, 0x7f041f80, 0x80370000,
0x0000103f, 0x00000000, 0x02c51f00, 0x80000000,
0xfea41f00, 0x80000020, 0xffa09f00, 0x80000040,
0xff001f80, 0x800c0060, 0x398ee33f, 0x0000103f,
0x02c41f00, 0x9000e00f, 0x02c59f01, 0x80000020,
0xfea81f00, 0x80000040, 0x02c19f80, 0x9000e06f,
0x398ee33f, 0x00000000, 0x02c11f01, 0x80000000,
0x02c49f80, 0x80000060, 0x02e08f01, 0xfe0c620f,
0x02c01f80, 0x7f00622f, 0xfe242000, 0x10000000,
0xfe20a080, 0x10000020, 0xf2178647, 0x49c0e9fb,
0xfbbdb2ab, 0x768ac733
};
static const uint32_t cpVertexShaderRegs[] = {
0x00000103,0x00000000,0x00000000,0x00000001,
0xffffff00,0xffffffff,0xffffffff,0xffffffff,
0xffffffff,0xffffffff,0xffffffff,0xffffffff,
0xffffffff,0xffffffff,0x00000000,0xfffffffc,
0x00000002,0x00000001,0x00000000,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x00000000,0x0000000e,0x00000010
0x00000103, 0x00000000, 0x00000000, 0x00000001,
0xffffff00, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0x00000000, 0xfffffffc,
0x00000002, 0x00000001, 0x00000000, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x00000000, 0x0000000e, 0x00000010
};
static const uint32_t cpPixelShaderProgram[] = {
0x20000000,0x00000ca0,0x00000000,0x88062094,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00002000,0x90000000,0x0004a000,0x90000020,
0x00082001,0x90000040,0x000ca081,0x90000060,
0xbb7dd898,0x9746c59c,0xc69b00e7,0x03c36218
0x20000000, 0x00000ca0, 0x00000000, 0x88062094,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00002000, 0x90000000, 0x0004a000, 0x90000020,
0x00082001, 0x90000040, 0x000ca081, 0x90000060,
0xbb7dd898, 0x9746c59c, 0xc69b00e7, 0x03c36218
};
static const uint32_t cpPixelShaderRegs[] = {
0x00000001,0x00000002,0x14000001,0x00000000,
0x00000001,0x00000100,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x0000000f,0x00000001,0x00000010,
0x00000000
0x00000001, 0x00000002, 0x14000001, 0x00000000,
0x00000001, 0x00000100, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x0000000f, 0x00000001, 0x00000010,
0x00000000
};
ColorShader * ColorShader::shaderInstance = NULL;
ColorShader *ColorShader::shaderInstance = NULL;
ColorShader::ColorShader()
: vertexShader(cuAttributeCount) {
: vertexShader(cuAttributeCount) {
//! create pixel shader
pixelShader.setProgram(cpPixelShaderProgram, sizeof(cpPixelShaderProgram), cpPixelShaderRegs, sizeof(cpPixelShaderRegs));
colorIntensityLocation = 0;
pixelShader.addUniformVar((GX2UniformVar) {
"unf_color_intensity", GX2_SHADER_VAR_TYPE_FLOAT4, 1, colorIntensityLocation, -1
"unf_color_intensity", GX2_SHADER_VAR_TYPE_FLOAT4, 1, colorIntensityLocation, -1
});
//! create vertex shader
@ -124,22 +124,22 @@ ColorShader::ColorShader()
offsetLocation = 4;
scaleLocation = 8;
vertexShader.addUniformVar((GX2UniformVar) {
"unf_angle", GX2_SHADER_VAR_TYPE_FLOAT, 1, angleLocation, -1
"unf_angle", GX2_SHADER_VAR_TYPE_FLOAT, 1, angleLocation, -1
});
vertexShader.addUniformVar((GX2UniformVar) {
"unf_offset", GX2_SHADER_VAR_TYPE_FLOAT3, 1, offsetLocation, -1
"unf_offset", GX2_SHADER_VAR_TYPE_FLOAT3, 1, offsetLocation, -1
});
vertexShader.addUniformVar((GX2UniformVar) {
"unf_scale", GX2_SHADER_VAR_TYPE_FLOAT3, 1, scaleLocation, -1
"unf_scale", GX2_SHADER_VAR_TYPE_FLOAT3, 1, scaleLocation, -1
});
colorLocation = 1;
positionLocation = 0;
vertexShader.addAttribVar((GX2AttribVar) {
"attr_color", GX2_SHADER_VAR_TYPE_FLOAT4, 0, colorLocation
"attr_color", GX2_SHADER_VAR_TYPE_FLOAT4, 0, colorLocation
});
vertexShader.addAttribVar((GX2AttribVar) {
"attr_position", GX2_SHADER_VAR_TYPE_FLOAT3, 0, positionLocation
"attr_position", GX2_SHADER_VAR_TYPE_FLOAT3, 0, positionLocation
});
//! setup attribute streams
@ -150,28 +150,28 @@ ColorShader::ColorShader()
fetchShader = new FetchShader(vertexShader.getAttributeBuffer(), vertexShader.getAttributesCount());
//! model vertex has to be align and cannot be in unknown regions for GX2 like 0xBCAE1000
positionVtxs = (float*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, cuPositionVtxsSize);
if(positionVtxs) {
positionVtxs = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, cuPositionVtxsSize);
if (positionVtxs) {
//! position vertex structure
int32_t i = 0;
positionVtxs[i++] = -1.0f;
positionVtxs[i++] = -1.0f;
positionVtxs[i++] = 0.0f;
positionVtxs[i++] = 1.0f;
positionVtxs[i++] = 1.0f;
positionVtxs[i++] = -1.0f;
positionVtxs[i++] = 0.0f;
positionVtxs[i++] = 1.0f;
positionVtxs[i++] = 1.0f;
positionVtxs[i++] = 1.0f;
positionVtxs[i++] = 1.0f;
positionVtxs[i++] = 0.0f;
positionVtxs[i++] = -1.0f;
positionVtxs[i++] = 1.0f;
positionVtxs[i++] = 1.0f;
positionVtxs[i++] = 0.0f;
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, positionVtxs, cuPositionVtxsSize);
}
}
ColorShader::~ColorShader() {
if(positionVtxs) {
if (positionVtxs) {
free(positionVtxs);
positionVtxs = NULL;
}

292
source/video/shaders/FXAAShader.cpp
View File

@ -19,163 +19,163 @@
#include <gui/video/shaders/FXAAShader.h>
static const uint32_t cpVertexShaderProgram[] = {
0x00000000,0x00008009,0x20000000,0x000004a0,
0x3ca00000,0x88060094,0x00400000,0xff0f2094,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0xfd001f80,0x900c2060,0x0000803f,0x00000000,
0xc1a229f5,0xd0eddc33,0x426618fd,0x8509cfe7
0x00000000, 0x00008009, 0x20000000, 0x000004a0,
0x3ca00000, 0x88060094, 0x00400000, 0xff0f2094,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xfd001f80, 0x900c2060, 0x0000803f, 0x00000000,
0xc1a229f5, 0xd0eddc33, 0x426618fd, 0x8509cfe7
};
static const uint32_t cpVertexShaderRegs[] = {
0x00000102,0x00000000,0x00000000,0x00000001,
0xffffffff,0xffffffff,0xffffffff,0xffffffff,
0xffffffff,0xffffffff,0xffffffff,0xffffffff,
0xffffffff,0xffffffff,0x00000000,0xfffffffe,
0x00000001,0x00000000,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x00000000,0x0000000e,0x00000010
0x00000102, 0x00000000, 0x00000000, 0x00000001,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0x00000000, 0xfffffffe,
0x00000001, 0x00000000, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x00000000, 0x0000000e, 0x00000010
};
static const uint32_t cpPixelShaderProgram[] = {
0x20000000,0x00003ca0,0xa0000000,0x000c8080,
0x30000000,0x000010a1,0xa8000000,0x0010c080,
0x75000000,0x000088a0,0x00800100,0x88062094,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00241f02,0x1000e00f,0x00241f00,0x1000e02f,
0x00201f02,0x00000040,0x00201f00,0x00000060,
0x00011f80,0x10332060,0xff000000,0xff102200,
0xfd001f00,0x900cc020,0xffc09f01,0x90004040,
0xffc01f01,0x90000060,0x00051f80,0x1033a040,
0x0000803f,0x00000000,0xffe00f00,0x90004000,
0xff008000,0xff102220,0xffe08f00,0x90000440,
0x010c0000,0x010c4660,0xff008080,0xff004220,
0x01a01f00,0x00280000,0x01a49f00,0x00280020,
0x01a81f01,0x00280040,0xfd0c1f00,0x1028e06f,
0x00208081,0x90002000,0x8716993e,0xa245163f,
0xd578e93d,0x00000080,0x03a01f00,0x00280000,
0x03a49f00,0x00280020,0x03a81f01,0x1028e04f,
0xfd0c1f00,0x00280060,0x00a40081,0x90002020,
0x8716993e,0xa245163f,0xd578e93d,0x00000080,
0x04a01f00,0x00280000,0x04a49f00,0x1028a02f,
0x04a81f01,0x00280040,0xfd0c1f00,0x00280060,
0x7fcc1f80,0x1000c02f,0x8716993e,0xa245163f,
0xd578e93d,0x00000080,0x02a01f00,0x1028e00f,
0x02a49f00,0x00280020,0x02a81f01,0x00280040,
0xfd0c1f00,0x00280060,0x7fcc1f80,0x1000e02f,
0x8716993e,0xa245163f,0xd578e93d,0x00000080,
0x7dc41f00,0x00020000,0x7fec0f01,0x00020020,
0x7fc81f00,0x00000040,0x7dc41f00,0x00000060,
0x7fec0f81,0x9001802f,0xfef88f00,0x1000e00f,
0xfedc8f00,0x00000420,0x7de40f00,0x80010040,
0x7ec49f01,0x00001060,0xfec41f80,0x10024060,
0xfed49f00,0x80020000,0xfe141f00,0x900c802f,
0xfeac1f00,0x80000040,0xfec01f02,0x80020060,
0x7cc41f81,0x90010060,0x0000003d,0x00000000,
0xfd001f00,0x900c6000,0xfea89f00,0x80010020,
0xfec09f81,0x00020040,0x0000803f,0x0000003e,
0xfec41f81,0x00000020,0xfe041f80,0x00330000,
0x7fe01f00,0x80000040,0x7ce41f80,0x80000060,
0xfea81f00,0x80010000,0xfeac1f80,0x80010020,
0x000000c1,0x00000000,0xfea01f00,0x00020040,
0xfea41f80,0x00020060,0x00000041,0x00000000,
0x05c81f01,0x9000e00f,0x01cc9f81,0x9000e06f,
0xfeac1f00,0x01004200,0xfea01f00,0x01044220,
0xfeac9f00,0x01002240,0xfea09f00,0x01042260,
0xfe8c1f80,0x01008600,0xacaa2a3e,0xaaaa2abe,
0x7f9c1f00,0x0100a200,0x7f801f00,0x01048220,
0x7f901f80,0x0104a240,0x02080001,0x7000a00f,
0x02000000,0x7000c04f,0x02048000,0x7000e06f,
0x01a81f80,0x9000e00f,0xd578e93d,0x00000000,
0x04a80001,0x1000c00f,0x04a48000,0x00000020,
0x04a00000,0x00000040,0xfe081f00,0xe00c0060,
0xfe0c1f80,0xe00c0000,0x01a41f00,0x7f00620f,
0xfea89f00,0xfe0c822f,0xfea49f00,0xff00a24f,
0x7d001f80,0xe00c0060,0xa245163f,0x0000803e,
0x7ea01f00,0xfe0ce20f,0x01a09f80,0xfe006a4f,
0x0000803e,0x8716993e,0xfe088001,0x9001c00f,
0xfe488001,0x1002e44f,0xfea01f80,0x80000000,
0xd578e93d,0x00000000,0x7ca41f00,0x00280000,
0x7da89f00,0x00280020,0xff201f00,0x00280040,
0xfd081f80,0x00280060,0x8716993e,0xa245163f,
0x00000080,0x00000000,0x7fc81f00,0x80060000,
0xfec00f80,0x80060060,0xfec09f81,0xfb80634f,
0xfe888f00,0x7e886300,0xfea80f01,0x7f8c6320,
0xfee80f00,0x7d806340,0xfe680080,0x06846f60,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x10000100,0x01101df0,0x00008010,0xecdfea0d,
0x10000200,0x03101df0,0x00002050,0xecdfea0d,
0x10000000,0x04101df0,0x00003071,0xecdfea0d,
0x10000200,0x02101df0,0x0000b070,0xecdfea0d,
0x10000200,0x02101df0,0x00008010,0xecdfea0d,
0x10000100,0x00101df0,0x0000a051,0xecdfea0d,
0x10000400,0x04101df0,0x00008010,0xecdfea0d,
0x10000500,0x05101df0,0x00000011,0xecdfea0d,
0x10000100,0x01101df0,0x00008010,0xecdfea0d,
0xfe2e963a,0x0269a9a3,0x38f88096,0x400cf48b
0x20000000, 0x00003ca0, 0xa0000000, 0x000c8080,
0x30000000, 0x000010a1, 0xa8000000, 0x0010c080,
0x75000000, 0x000088a0, 0x00800100, 0x88062094,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00241f02, 0x1000e00f, 0x00241f00, 0x1000e02f,
0x00201f02, 0x00000040, 0x00201f00, 0x00000060,
0x00011f80, 0x10332060, 0xff000000, 0xff102200,
0xfd001f00, 0x900cc020, 0xffc09f01, 0x90004040,
0xffc01f01, 0x90000060, 0x00051f80, 0x1033a040,
0x0000803f, 0x00000000, 0xffe00f00, 0x90004000,
0xff008000, 0xff102220, 0xffe08f00, 0x90000440,
0x010c0000, 0x010c4660, 0xff008080, 0xff004220,
0x01a01f00, 0x00280000, 0x01a49f00, 0x00280020,
0x01a81f01, 0x00280040, 0xfd0c1f00, 0x1028e06f,
0x00208081, 0x90002000, 0x8716993e, 0xa245163f,
0xd578e93d, 0x00000080, 0x03a01f00, 0x00280000,
0x03a49f00, 0x00280020, 0x03a81f01, 0x1028e04f,
0xfd0c1f00, 0x00280060, 0x00a40081, 0x90002020,
0x8716993e, 0xa245163f, 0xd578e93d, 0x00000080,
0x04a01f00, 0x00280000, 0x04a49f00, 0x1028a02f,
0x04a81f01, 0x00280040, 0xfd0c1f00, 0x00280060,
0x7fcc1f80, 0x1000c02f, 0x8716993e, 0xa245163f,
0xd578e93d, 0x00000080, 0x02a01f00, 0x1028e00f,
0x02a49f00, 0x00280020, 0x02a81f01, 0x00280040,
0xfd0c1f00, 0x00280060, 0x7fcc1f80, 0x1000e02f,
0x8716993e, 0xa245163f, 0xd578e93d, 0x00000080,
0x7dc41f00, 0x00020000, 0x7fec0f01, 0x00020020,
0x7fc81f00, 0x00000040, 0x7dc41f00, 0x00000060,
0x7fec0f81, 0x9001802f, 0xfef88f00, 0x1000e00f,
0xfedc8f00, 0x00000420, 0x7de40f00, 0x80010040,
0x7ec49f01, 0x00001060, 0xfec41f80, 0x10024060,
0xfed49f00, 0x80020000, 0xfe141f00, 0x900c802f,
0xfeac1f00, 0x80000040, 0xfec01f02, 0x80020060,
0x7cc41f81, 0x90010060, 0x0000003d, 0x00000000,
0xfd001f00, 0x900c6000, 0xfea89f00, 0x80010020,
0xfec09f81, 0x00020040, 0x0000803f, 0x0000003e,
0xfec41f81, 0x00000020, 0xfe041f80, 0x00330000,
0x7fe01f00, 0x80000040, 0x7ce41f80, 0x80000060,
0xfea81f00, 0x80010000, 0xfeac1f80, 0x80010020,
0x000000c1, 0x00000000, 0xfea01f00, 0x00020040,
0xfea41f80, 0x00020060, 0x00000041, 0x00000000,
0x05c81f01, 0x9000e00f, 0x01cc9f81, 0x9000e06f,
0xfeac1f00, 0x01004200, 0xfea01f00, 0x01044220,
0xfeac9f00, 0x01002240, 0xfea09f00, 0x01042260,
0xfe8c1f80, 0x01008600, 0xacaa2a3e, 0xaaaa2abe,
0x7f9c1f00, 0x0100a200, 0x7f801f00, 0x01048220,
0x7f901f80, 0x0104a240, 0x02080001, 0x7000a00f,
0x02000000, 0x7000c04f, 0x02048000, 0x7000e06f,
0x01a81f80, 0x9000e00f, 0xd578e93d, 0x00000000,
0x04a80001, 0x1000c00f, 0x04a48000, 0x00000020,
0x04a00000, 0x00000040, 0xfe081f00, 0xe00c0060,
0xfe0c1f80, 0xe00c0000, 0x01a41f00, 0x7f00620f,
0xfea89f00, 0xfe0c822f, 0xfea49f00, 0xff00a24f,
0x7d001f80, 0xe00c0060, 0xa245163f, 0x0000803e,
0x7ea01f00, 0xfe0ce20f, 0x01a09f80, 0xfe006a4f,
0x0000803e, 0x8716993e, 0xfe088001, 0x9001c00f,
0xfe488001, 0x1002e44f, 0xfea01f80, 0x80000000,
0xd578e93d, 0x00000000, 0x7ca41f00, 0x00280000,
0x7da89f00, 0x00280020, 0xff201f00, 0x00280040,
0xfd081f80, 0x00280060, 0x8716993e, 0xa245163f,
0x00000080, 0x00000000, 0x7fc81f00, 0x80060000,
0xfec00f80, 0x80060060, 0xfec09f81, 0xfb80634f,
0xfe888f00, 0x7e886300, 0xfea80f01, 0x7f8c6320,
0xfee80f00, 0x7d806340, 0xfe680080, 0x06846f60,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x10000100, 0x01101df0, 0x00008010, 0xecdfea0d,
0x10000200, 0x03101df0, 0x00002050, 0xecdfea0d,
0x10000000, 0x04101df0, 0x00003071, 0xecdfea0d,
0x10000200, 0x02101df0, 0x0000b070, 0xecdfea0d,
0x10000200, 0x02101df0, 0x00008010, 0xecdfea0d,
0x10000100, 0x00101df0, 0x0000a051, 0xecdfea0d,
0x10000400, 0x04101df0, 0x00008010, 0xecdfea0d,
0x10000500, 0x05101df0, 0x00000011, 0xecdfea0d,
0x10000100, 0x01101df0, 0x00008010, 0xecdfea0d,
0xfe2e963a, 0x0269a9a3, 0x38f88096, 0x400cf48b
};
static const uint32_t cpPixelShaderRegs[] = {
0x00000007,0x00000002,0x04000101,0x00000000,
0x00000001,0x00000100,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x0000000f,0x00000001,0x00000010,
0x00000000
0x00000007, 0x00000002, 0x04000101, 0x00000000,
0x00000001, 0x00000100, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x0000000f, 0x00000001, 0x00000010,
0x00000000
};
FXAAShader * FXAAShader::shaderInstance = NULL;
FXAAShader *FXAAShader::shaderInstance = NULL;
FXAAShader::FXAAShader()
: vertexShader(cuAttributeCount) {
: vertexShader(cuAttributeCount) {
//! create pixel shader
pixelShader.setProgram(cpPixelShaderProgram, sizeof(cpPixelShaderProgram), cpPixelShaderRegs, sizeof(cpPixelShaderRegs));
resolutionLocation = 0;
pixelShader.addUniformVar((GX2UniformVar) {
"unf_resolution", GX2_SHADER_VAR_TYPE_FLOAT2, 1, resolutionLocation, -1
"unf_resolution", GX2_SHADER_VAR_TYPE_FLOAT2, 1, resolutionLocation, -1
});
samplerLocation = 0;
pixelShader.addSamplerVar((GX2SamplerVar) {
"sampl_texture", GX2_SAMPLER_VAR_TYPE_SAMPLER_2D, samplerLocation
"sampl_texture", GX2_SAMPLER_VAR_TYPE_SAMPLER_2D, samplerLocation
});
//! create vertex shader
@ -184,10 +184,10 @@ FXAAShader::FXAAShader()
positionLocation = 0;
texCoordLocation = 1;
vertexShader.addAttribVar((GX2AttribVar) {
"attr_position", GX2_SHADER_VAR_TYPE_FLOAT3, 0, positionLocation
"attr_position", GX2_SHADER_VAR_TYPE_FLOAT3, 0, positionLocation
});
vertexShader.addAttribVar((GX2AttribVar) {
"attr_texture_coord", GX2_SHADER_VAR_TYPE_FLOAT2, 0, texCoordLocation
"attr_texture_coord", GX2_SHADER_VAR_TYPE_FLOAT2, 0, texCoordLocation
});
//! setup attribute streams
@ -198,22 +198,22 @@ FXAAShader::FXAAShader()
fetchShader = new FetchShader(vertexShader.getAttributeBuffer(), vertexShader.getAttributesCount());
//! model vertex has to be align and cannot be in unknown regions for GX2 like 0xBCAE1000
posVtxs = (float*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciPositionVtxsSize);
texCoords = (float*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciTexCoordsVtxsSize);
posVtxs = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciPositionVtxsSize);
texCoords = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciTexCoordsVtxsSize);
//! position vertex structure and texture coordinate vertex structure
int32_t i = 0;
posVtxs[i++] = -1.0f;
posVtxs[i++] = -1.0f;
posVtxs[i++] = 0.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = -1.0f;
posVtxs[i++] = 0.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 0.0f;
posVtxs[i++] = -1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 0.0f;
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, posVtxs, ciPositionVtxsSize);
@ -230,11 +230,11 @@ FXAAShader::FXAAShader()
}
FXAAShader::~FXAAShader() {
if(posVtxs) {
if (posVtxs) {
free(posVtxs);
posVtxs = NULL;
}
if(texCoords) {
if (texCoords) {
free(texCoords);
texCoords = NULL;
}

350
source/video/shaders/Shader3D.cpp
View File

@ -19,176 +19,176 @@
#include <gui/video/shaders/Shader3D.h>
static const uint32_t cpVertexShaderProgram[] = {
0x00000000,0x00008009,0x20000000,0x0000e4a1,
0x00c00100,0x88048093,0x01c00300,0x98060014,
0x9a000000,0x000058a0,0x3c200200,0x88062094,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x0765a101,0x9000e00f,0x0761a101,0x9000e02f,
0x01081f00,0x900ce040,0x01041f00,0x900ce060,
0x01001f80,0x900ce000,0x02001f00,0x900c6000,
0x02041f00,0x900c6020,0x076da101,0x9000e04f,
0x0769a181,0x9000e06f,0x0745a101,0x9000c00f,
0x0741a181,0x9000c02f,0x074da101,0x9000c04f,
0x0749a181,0x9000c06f,0x0bc9a000,0x7f00e20f,
0x0bc92080,0x7f04e22f,0x0bc9a001,0x7f08e24f,
0x0bc92081,0x7f0ce26f,0x0725a101,0x9000a00f,
0x0721a181,0x9000a02f,0x072da101,0x9000a04f,
0x0729a181,0x9000a06f,0x0ac9a000,0x7e00c20f,
0x0ac92080,0x7e04c22f,0x0ac9a001,0x7e08c24f,
0x0ac92081,0x7e0cc26f,0x0ba5a000,0x7f00e20f,
0x0ba52080,0x7f04e22f,0x0ba5a001,0x7f08e24f,
0x0ba52081,0x7f0ce26f,0x08eda000,0x9000800f,
0x08ed2080,0x9000802f,0x08eda001,0x9000804f,
0x08ed2081,0x9000806f,0x09c9a000,0x7d00a20f,
0x09c92080,0x7d04a22f,0x09c9a001,0x7d08a24f,
0x09c92081,0x7d0ca26f,0x0aa5a000,0x7e00c20f,
0x0aa52080,0x7e04c22f,0x0aa5a001,0x7e08c24f,
0x0aa52081,0x7e0cc26f,0x0b81a000,0x7f004200,
0x0b812080,0x7f044220,0x0b81a001,0x7f082240,
0x0b812081,0x7f0c0260,0x08c9a000,0x7c00820f,
0x08c92080,0x7c04822f,0x08c9a001,0x7c08824f,
0x08c92081,0x7c0c826f,0x09a5a000,0x7d00a20f,
0x09a52080,0x7d04a22f,0x09a5a001,0x7d08a24f,
0x09a52081,0x7d0ca26f,0x0a81a000,0x7e000200,
0x0a812080,0x7e040220,0x0a81a001,0x7e080240,
0x0a812081,0x7e0c2260,0x0240a001,0x9000c00f,
0x0244a001,0x9000c02f,0x0148a001,0x9000c04f,
0x004ca001,0x9000c06f,0x0264a081,0x9000e02f,
0x0260a001,0x9000e00f,0x0224a001,0x90002020,
0x0168a001,0x9000e04f,0x006ca001,0x9000e06f,
0x0220a081,0x90002000,0x08a5a000,0x7c00820f,
0x08a52080,0x7c04822f,0x08a5a001,0x7c08824f,
0x08a52081,0x7c0c826f,0x0981a000,0x7d008200,
0x09812080,0x7d048220,0x0981a001,0x7d084240,
0x09812081,0x7d0c4260,0x02090000,0x7e00c20f,
0x02098000,0x7e04c22f,0x0128a001,0x9000a04f,
0x002ca001,0x9000c06f,0x02298081,0x7e0caa6f,
0x03090000,0x7f00e20f,0x03098000,0x7f04e22f,
0x02090001,0x7e08f64f,0x03298001,0x7f0ce26f,
0x03090081,0x7f08ca4f,0x0881a000,0x7c00c200,
0x08812080,0x7c04e220,0x0881a001,0x7c08a240,
0x08812081,0x7c0c8260,0x0200a001,0x9000800f,
0x0204a001,0x9000802f,0x0108a001,0x9000804f,
0x000ca001,0x9000806f,0x01098080,0x0104aa2f,
0x01090000,0x0100a20f,0x02858000,0x7e04c22f,
0x01090001,0x7d08a24f,0x01298081,0x7e0cc26f,
0x02850000,0x7e00f60f,0x03858000,0x7f04622f,
0x02450001,0x7f08e24f,0x02458001,0x7d0ca26f,
0x03850080,0x7f00ca0f,0x00090000,0x7c004200,
0x00098000,0x7c04b220,0x03450001,0x7e08c24f,
0x03458001,0x7f0ce26f,0x03e18080,0xfe042620,
0x01850000,0x7d00a200,0x01858000,0x7d04622f,
0x00090001,0x7c086240,0x00298081,0x7c0c0260,
0x02c10000,0x7f000200,0x02e18000,0x7e040620,
0x01450001,0x7d088240,0x01458001,0x7e0c6260,
0x01e18080,0xfe04c620,0x03c10000,0x7e002200,
0x03818001,0x7f0c4220,0x02a10001,0x7f081640,
0x02818001,0x7d0c3660,0x03a10081,0x7e082a40,
0x07080000,0x0100c20f,0x07088000,0x0104622f,
0x00458001,0x000cea4f,0x07288081,0x0204f66f,
0x00850000,0x0200620f,0x00858000,0x05046a2f,
0x07080001,0x0108c24f,0x01818001,0x030c726f,
0x07cc8080,0xfe04c22f,0x01c10000,0x0500660f,
0x00e18000,0xfe04622f,0x00450001,0x0308624f,
0x07cc9f01,0x7f0ce26f,0x00c10080,0xfe00e60f,
0x07cc1f00,0x7e00660f,0x00a10001,0xfe08c22f,
0x01a10001,0x0408624f,0x00818001,0x7f086a6f,
0x07c09f80,0x7e048200,0x07e00f00,0xfe008220,
0x07cc1f01,0x7e086a4f,0x07c09f81,0x7f0c8240,
0x07c08f80,0xfe088260,0x2c34800d,0xe3b4f15e,
0x7642ed30,0x7408600d
0x00000000, 0x00008009, 0x20000000, 0x0000e4a1,
0x00c00100, 0x88048093, 0x01c00300, 0x98060014,
0x9a000000, 0x000058a0, 0x3c200200, 0x88062094,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x0765a101, 0x9000e00f, 0x0761a101, 0x9000e02f,
0x01081f00, 0x900ce040, 0x01041f00, 0x900ce060,
0x01001f80, 0x900ce000, 0x02001f00, 0x900c6000,
0x02041f00, 0x900c6020, 0x076da101, 0x9000e04f,
0x0769a181, 0x9000e06f, 0x0745a101, 0x9000c00f,
0x0741a181, 0x9000c02f, 0x074da101, 0x9000c04f,
0x0749a181, 0x9000c06f, 0x0bc9a000, 0x7f00e20f,
0x0bc92080, 0x7f04e22f, 0x0bc9a001, 0x7f08e24f,
0x0bc92081, 0x7f0ce26f, 0x0725a101, 0x9000a00f,
0x0721a181, 0x9000a02f, 0x072da101, 0x9000a04f,
0x0729a181, 0x9000a06f, 0x0ac9a000, 0x7e00c20f,
0x0ac92080, 0x7e04c22f, 0x0ac9a001, 0x7e08c24f,
0x0ac92081, 0x7e0cc26f, 0x0ba5a000, 0x7f00e20f,
0x0ba52080, 0x7f04e22f, 0x0ba5a001, 0x7f08e24f,
0x0ba52081, 0x7f0ce26f, 0x08eda000, 0x9000800f,
0x08ed2080, 0x9000802f, 0x08eda001, 0x9000804f,
0x08ed2081, 0x9000806f, 0x09c9a000, 0x7d00a20f,
0x09c92080, 0x7d04a22f, 0x09c9a001, 0x7d08a24f,
0x09c92081, 0x7d0ca26f, 0x0aa5a000, 0x7e00c20f,
0x0aa52080, 0x7e04c22f, 0x0aa5a001, 0x7e08c24f,
0x0aa52081, 0x7e0cc26f, 0x0b81a000, 0x7f004200,
0x0b812080, 0x7f044220, 0x0b81a001, 0x7f082240,
0x0b812081, 0x7f0c0260, 0x08c9a000, 0x7c00820f,
0x08c92080, 0x7c04822f, 0x08c9a001, 0x7c08824f,
0x08c92081, 0x7c0c826f, 0x09a5a000, 0x7d00a20f,
0x09a52080, 0x7d04a22f, 0x09a5a001, 0x7d08a24f,
0x09a52081, 0x7d0ca26f, 0x0a81a000, 0x7e000200,
0x0a812080, 0x7e040220, 0x0a81a001, 0x7e080240,
0x0a812081, 0x7e0c2260, 0x0240a001, 0x9000c00f,
0x0244a001, 0x9000c02f, 0x0148a001, 0x9000c04f,
0x004ca001, 0x9000c06f, 0x0264a081, 0x9000e02f,
0x0260a001, 0x9000e00f, 0x0224a001, 0x90002020,
0x0168a001, 0x9000e04f, 0x006ca001, 0x9000e06f,
0x0220a081, 0x90002000, 0x08a5a000, 0x7c00820f,
0x08a52080, 0x7c04822f, 0x08a5a001, 0x7c08824f,
0x08a52081, 0x7c0c826f, 0x0981a000, 0x7d008200,
0x09812080, 0x7d048220, 0x0981a001, 0x7d084240,
0x09812081, 0x7d0c4260, 0x02090000, 0x7e00c20f,
0x02098000, 0x7e04c22f, 0x0128a001, 0x9000a04f,
0x002ca001, 0x9000c06f, 0x02298081, 0x7e0caa6f,
0x03090000, 0x7f00e20f, 0x03098000, 0x7f04e22f,
0x02090001, 0x7e08f64f, 0x03298001, 0x7f0ce26f,
0x03090081, 0x7f08ca4f, 0x0881a000, 0x7c00c200,
0x08812080, 0x7c04e220, 0x0881a001, 0x7c08a240,
0x08812081, 0x7c0c8260, 0x0200a001, 0x9000800f,
0x0204a001, 0x9000802f, 0x0108a001, 0x9000804f,
0x000ca001, 0x9000806f, 0x01098080, 0x0104aa2f,
0x01090000, 0x0100a20f, 0x02858000, 0x7e04c22f,
0x01090001, 0x7d08a24f, 0x01298081, 0x7e0cc26f,
0x02850000, 0x7e00f60f, 0x03858000, 0x7f04622f,
0x02450001, 0x7f08e24f, 0x02458001, 0x7d0ca26f,
0x03850080, 0x7f00ca0f, 0x00090000, 0x7c004200,
0x00098000, 0x7c04b220, 0x03450001, 0x7e08c24f,
0x03458001, 0x7f0ce26f, 0x03e18080, 0xfe042620,
0x01850000, 0x7d00a200, 0x01858000, 0x7d04622f,
0x00090001, 0x7c086240, 0x00298081, 0x7c0c0260,
0x02c10000, 0x7f000200, 0x02e18000, 0x7e040620,
0x01450001, 0x7d088240, 0x01458001, 0x7e0c6260,
0x01e18080, 0xfe04c620, 0x03c10000, 0x7e002200,
0x03818001, 0x7f0c4220, 0x02a10001, 0x7f081640,
0x02818001, 0x7d0c3660, 0x03a10081, 0x7e082a40,
0x07080000, 0x0100c20f, 0x07088000, 0x0104622f,
0x00458001, 0x000cea4f, 0x07288081, 0x0204f66f,
0x00850000, 0x0200620f, 0x00858000, 0x05046a2f,
0x07080001, 0x0108c24f, 0x01818001, 0x030c726f,
0x07cc8080, 0xfe04c22f, 0x01c10000, 0x0500660f,
0x00e18000, 0xfe04622f, 0x00450001, 0x0308624f,
0x07cc9f01, 0x7f0ce26f, 0x00c10080, 0xfe00e60f,
0x07cc1f00, 0x7e00660f, 0x00a10001, 0xfe08c22f,
0x01a10001, 0x0408624f, 0x00818001, 0x7f086a6f,
0x07c09f80, 0x7e048200, 0x07e00f00, 0xfe008220,
0x07cc1f01, 0x7e086a4f, 0x07c09f81, 0x7f0c8240,
0x07c08f80, 0xfe088260, 0x2c34800d, 0xe3b4f15e,
0x7642ed30, 0x7408600d
};
static const uint32_t cpVertexShaderRegs[] = {
0x00000108,0x00000000,0x00000002,0x00000001,
0xffff0001,0xffffffff,0xffffffff,0xffffffff,
0xffffffff,0xffffffff,0xffffffff,0xffffffff,
0xffffffff,0xffffffff,0x00000000,0xfffffffc,
0x00000002,0x00000000,0x00000001,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x00000000,0x0000000e,0x00000010
0x00000108, 0x00000000, 0x00000002, 0x00000001,
0xffff0001, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0x00000000, 0xfffffffc,
0x00000002, 0x00000000, 0x00000001, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x00000000, 0x0000000e, 0x00000010
};
static const uint32_t cPixelShaderProgram[] = {
0x20000000,0x000008a4,0x03000000,0x01004085,
0x23000000,0x000044a8,0x35000000,0x000000a4,
0x06000000,0x01004085,0x36000000,0x00002ca8,
0x50000000,0x0000c080,0x42000000,0x00001ca0,
0x00800000,0x88062094,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0xfd001f80,0x900c0060,0x0000803f,0x00000000,
0x02011f80,0x8c110000,0xf8402000,0x9006a00f,
0x02552001,0x00000020,0x01248082,0x80020060,
0xfe3c1f00,0x1000e04f,0xfe041f80,0x1033c00f,
0xfe482081,0x80060020,0xfee40f81,0x0289e30f,
0x02c51f80,0x80060060,0xfeec0f80,0x0285634f,
0xfec80f80,0x80000060,0xfe4ca081,0x9000e04f,
0xfe281f00,0x80060000,0xf8c01f81,0x9006e02f,
0xfee00f81,0xfd80636f,0x0000803f,0x00000000,
0x7fc49f81,0xf880e34f,0xfe381f80,0x00000000,
0x7de00f81,0xfe800360,0x01011f80,0x8c100000,
0x00a81f00,0x9000e02f,0x00000082,0x80020060,
0x00002040,0x00000000,0xfeac9f80,0xfd00624f,
0x3333333f,0x00002040,0xfee88f80,0x0101620f,
0x00cc1f80,0x9000e06f,0xf8c09f01,0x80060020,
0xfe2c1f80,0x9006e04f,0xfee48f81,0xf880630f,
0x7fc81f80,0xfd800360,0x0000803f,0x00000000,
0x000ca001,0x80000000,0x00091f00,0x800c0020,
0x00051f00,0x800c0040,0x00011f80,0x800c0060,
0xfe2c0000,0x90002000,0xfe288000,0x90002020,
0xfe240001,0x90002040,0xfe208081,0x90002060,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x10000100,0x01100df0,0x00008010,0xecdfea0d,
0x99720984,0x041cab0d,0xa28a9ccd,0x95d199a5
0x20000000, 0x000008a4, 0x03000000, 0x01004085,
0x23000000, 0x000044a8, 0x35000000, 0x000000a4,
0x06000000, 0x01004085, 0x36000000, 0x00002ca8,
0x50000000, 0x0000c080, 0x42000000, 0x00001ca0,
0x00800000, 0x88062094, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xfd001f80, 0x900c0060, 0x0000803f, 0x00000000,
0x02011f80, 0x8c110000, 0xf8402000, 0x9006a00f,
0x02552001, 0x00000020, 0x01248082, 0x80020060,
0xfe3c1f00, 0x1000e04f, 0xfe041f80, 0x1033c00f,
0xfe482081, 0x80060020, 0xfee40f81, 0x0289e30f,
0x02c51f80, 0x80060060, 0xfeec0f80, 0x0285634f,
0xfec80f80, 0x80000060, 0xfe4ca081, 0x9000e04f,
0xfe281f00, 0x80060000, 0xf8c01f81, 0x9006e02f,
0xfee00f81, 0xfd80636f, 0x0000803f, 0x00000000,
0x7fc49f81, 0xf880e34f, 0xfe381f80, 0x00000000,
0x7de00f81, 0xfe800360, 0x01011f80, 0x8c100000,
0x00a81f00, 0x9000e02f, 0x00000082, 0x80020060,
0x00002040, 0x00000000, 0xfeac9f80, 0xfd00624f,
0x3333333f, 0x00002040, 0xfee88f80, 0x0101620f,
0x00cc1f80, 0x9000e06f, 0xf8c09f01, 0x80060020,
0xfe2c1f80, 0x9006e04f, 0xfee48f81, 0xf880630f,
0x7fc81f80, 0xfd800360, 0x0000803f, 0x00000000,
0x000ca001, 0x80000000, 0x00091f00, 0x800c0020,
0x00051f00, 0x800c0040, 0x00011f80, 0x800c0060,
0xfe2c0000, 0x90002000, 0xfe288000, 0x90002020,
0xfe240001, 0x90002040, 0xfe208081, 0x90002060,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x10000100, 0x01100df0, 0x00008010, 0xecdfea0d,
0x99720984, 0x041cab0d, 0xa28a9ccd, 0x95d199a5
};
static const uint32_t cPixelShaderRegs[] = {
0x00000102,0x00000002,0x14000002,0x00000000,
0x00000002,0x00000100,0x00000101,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x0000000f,0x00000001,0x00000010,
0x00000000
0x00000102, 0x00000002, 0x14000002, 0x00000000,
0x00000002, 0x00000100, 0x00000101, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x0000000f, 0x00000001, 0x00000010,
0x00000000
};
Shader3D * Shader3D::shaderInstance = NULL;
Shader3D *Shader3D::shaderInstance = NULL;
Shader3D::Shader3D()
: vertexShader(cuAttributeCount) {
: vertexShader(cuAttributeCount) {
//! create pixel shader
pixelShader.setProgram(cPixelShaderProgram, sizeof(cPixelShaderProgram), cPixelShaderRegs, sizeof(cPixelShaderRegs));
@ -196,18 +196,18 @@ Shader3D::Shader3D()
fadeDistanceLocation = 4;
fadeOutLocation = 8;
pixelShader.addUniformVar((GX2UniformVar) {
"unf_color_intensity", GX2_SHADER_VAR_TYPE_FLOAT4, 1, colorIntensityLocation, -1
"unf_color_intensity", GX2_SHADER_VAR_TYPE_FLOAT4, 1, colorIntensityLocation, -1
});
pixelShader.addUniformVar((GX2UniformVar) {
"unf_fade_distance", GX2_SHADER_VAR_TYPE_FLOAT, 1, fadeDistanceLocation, -1
"unf_fade_distance", GX2_SHADER_VAR_TYPE_FLOAT, 1, fadeDistanceLocation, -1
});
pixelShader.addUniformVar((GX2UniformVar) {
"unf_fade_out_alpha", GX2_SHADER_VAR_TYPE_FLOAT4, 1, fadeOutLocation, -1
"unf_fade_out_alpha", GX2_SHADER_VAR_TYPE_FLOAT4, 1, fadeOutLocation, -1
});
samplerLocation = 0;
pixelShader.addSamplerVar((GX2SamplerVar) {
"sampl_texture", GX2_SAMPLER_VAR_TYPE_SAMPLER_2D, samplerLocation
"sampl_texture", GX2_SAMPLER_VAR_TYPE_SAMPLER_2D, samplerLocation
});
//! create vertex shader
vertexShader.setProgram(cpVertexShaderProgram, sizeof(cpVertexShaderProgram), cpVertexShaderRegs, sizeof(cpVertexShaderRegs));
@ -216,22 +216,22 @@ Shader3D::Shader3D()
projectionMatrixLocation = 16;
viewMatrixLocation = 32;
vertexShader.addUniformVar((GX2UniformVar) {
"modelMatrix", GX2_SHADER_VAR_TYPE_MATRIX4X4, 1, modelMatrixLocation, -1
"modelMatrix", GX2_SHADER_VAR_TYPE_MATRIX4X4, 1, modelMatrixLocation, -1
});
vertexShader.addUniformVar((GX2UniformVar) {
"viewMatrix", GX2_SHADER_VAR_TYPE_MATRIX4X4, 1, projectionMatrixLocation, -1
"viewMatrix", GX2_SHADER_VAR_TYPE_MATRIX4X4, 1, projectionMatrixLocation, -1
});
vertexShader.addUniformVar((GX2UniformVar) {
"projectionMatrix", GX2_SHADER_VAR_TYPE_MATRIX4X4, 1, viewMatrixLocation, -1
"projectionMatrix", GX2_SHADER_VAR_TYPE_MATRIX4X4, 1, viewMatrixLocation, -1
});
positionLocation = 0;
texCoordLocation = 1;
vertexShader.addAttribVar((GX2AttribVar) {
"attr_position", GX2_SHADER_VAR_TYPE_FLOAT4, 0, positionLocation
"attr_position", GX2_SHADER_VAR_TYPE_FLOAT4, 0, positionLocation
});
vertexShader.addAttribVar((GX2AttribVar) {
"attr_texture_coord", GX2_SHADER_VAR_TYPE_FLOAT2, 0, texCoordLocation
"attr_texture_coord", GX2_SHADER_VAR_TYPE_FLOAT2, 0, texCoordLocation
});
//! setup attribute streams
@ -243,22 +243,22 @@ Shader3D::Shader3D()
//! initialize default quad texture vertexes as those are very commonly used
//! model vertex has to be align and cannot be in unknown regions for GX2 like 0xBCAE1000
posVtxs = (float*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciPositionVtxsSize);
texCoords = (float*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciTexCoordsVtxsSize);
posVtxs = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciPositionVtxsSize);
texCoords = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciTexCoordsVtxsSize);
//! position vertex structure and texture coordinate vertex structure
int32_t i = 0;
posVtxs[i++] = -1.0f;
posVtxs[i++] = -1.0f;
posVtxs[i++] = 0.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = -1.0f;
posVtxs[i++] = 0.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 0.0f;
posVtxs[i++] = -1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 0.0f;
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, posVtxs, ciPositionVtxsSize);
@ -275,11 +275,11 @@ Shader3D::Shader3D()
}
Shader3D::~Shader3D() {
if(posVtxs) {
if (posVtxs) {
free(posVtxs);
posVtxs = NULL;
}
if(texCoords) {
if (texCoords) {
free(texCoords);
texCoords = NULL;
}

544
source/video/shaders/ShaderFractalColor.cpp
View File

@ -19,269 +19,269 @@
#include <gui/video/shaders/ShaderFractalColor.h>
static const uint32_t cpVertexShaderProgram[] = {
0x00000000,0x00008009,0x20000000,0x0000eca1,
0x00c00000,0x88068093,0x01400200,0x9a048013,
0x9c000000,0x000044a0,0x3c200000,0x88060094,
0x02400000,0x88062014,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x0765a101,0x9000e00f,0x0761a101,0x9000e02f,
0x03001f00,0x900c8040,0x03041f80,0x900c8060,
0x076da101,0x9000e04f,0x0769a181,0x9000e06f,
0x0745a101,0x9000c00f,0x0741a181,0x9000c02f,
0x074da101,0x9000c04f,0x0749a181,0x9000c06f,
0x0bc9a000,0x7f00e20f,0x0bc92080,0x7f04e22f,
0x0bc9a001,0x7f08e24f,0x0bc92081,0x7f0ce26f,
0x0725a101,0x9000a00f,0x0721a181,0x9000a02f,
0x072da101,0x9000a04f,0x0729a181,0x9000a06f,
0x0ac9a000,0x7e00c20f,0x0ac92080,0x7e04c22f,
0x0ac9a001,0x7e08c24f,0x0ac92081,0x7e0cc26f,
0x0ba5a000,0x7f00e20f,0x0ba52080,0x7f04e22f,
0x0ba5a001,0x7f08e24f,0x0ba52081,0x7f0ce26f,
0x08eda000,0x9000800f,0x08ed2080,0x9000802f,
0x08eda001,0x9000804f,0x08ed2081,0x9000806f,
0x09c9a000,0x7d00a20f,0x09c92080,0x7d04a22f,
0x09c9a001,0x7d08a24f,0x09c92081,0x7d0ca26f,
0x0aa5a000,0x7e00c20f,0x0aa52080,0x7e04c22f,
0x0aa5a001,0x7e08c24f,0x0aa52081,0x7e0cc26f,
0x0b81a000,0x7f006200,0x0b812080,0x7f046220,
0x0b81a001,0x7f080240,0x0b812081,0x7f0c0260,
0x08c9a000,0x7c00820f,0x08c92080,0x7c04822f,
0x08c9a001,0x7c08824f,0x08c92081,0x7c0c826f,
0x09a5a000,0x7d00a20f,0x09a52080,0x7d04a22f,
0x09a5a001,0x7d08a24f,0x09a52081,0x7d0ca26f,
0x0a81a000,0x7e008200,0x0a812080,0x7e048220,
0x0a81a001,0x7e086240,0x0a812081,0x7e0c4260,
0x0340a001,0x9000c00f,0x0344a001,0x9000c02f,
0x0048a001,0x9000c04f,0x004ca001,0x9000c06f,
0x0364a081,0x9000e02f,0x0360a001,0x9000e00f,
0x0324a001,0x90000020,0x0068a001,0x9000e04f,
0x006ca001,0x9000e06f,0x0320a081,0x90000000,
0x08a5a000,0x7c00820f,0x08a52080,0x7c04822f,
0x08a5a001,0x7c08824f,0x08a52081,0x7c0c826f,
0x0981a000,0x7d00a200,0x09812080,0x7d04a220,
0x0981a001,0x7d08a240,0x09812081,0x7d0c6260,
0x02890000,0x7e00c20f,0x02898000,0x7e04c22f,
0x0028a001,0x9000a04f,0x002ca001,0x9000c06f,
0x02498081,0x7e0caa6f,0x03890000,0x7f00e20f,
0x03898000,0x7f04e22f,0x02690001,0x7e08f64f,
0x03498001,0x7f0ce26f,0x03690081,0x7f08ca4f,
0x0881a000,0x7c00c200,0x08812080,0x7c04c220,
0x0881a001,0x7c08e240,0x08812081,0x7c0ca260,
0x0300a001,0x9000800f,0x0304a001,0x9000802f,
0x0008a001,0x9000804f,0x000ca001,0x9000806f,
0x01898080,0x0004aa2f,0x01890000,0x0000a20f,
0x02a58000,0x7e04c22f,0x01690001,0x7d08a24f,
0x01498081,0x7e0cc26f,0x02a50000,0x7e00f60f,
0x03a58000,0x7f04622f,0x02a50001,0x7f08e24f,
0x02658001,0x7d0ca26f,0x03a50080,0x7f00ca0f,
0x00890000,0x7c00820f,0x00898000,0x7c049220,
0x03a50001,0x7e08c24f,0x03658001,0x7f0ce26f,
0x03c18080,0xfe04862f,0x01a50000,0x7d008200,
0x01a58000,0x7d04622f,0x00690001,0x7c086240,
0x00498081,0x7c0c4260,0x02c10000,0x7f00e20f,
0x02c18000,0x7e04c62f,0x01a50001,0x7d080240,
0x01658001,0x7e0c0260,0x01c18080,0xfe040620,
0x03c10000,0x7e00620f,0x03a18001,0x7f0c622f,
0x02e10001,0x7f08764f,0x02a18001,0x7d0c766f,
0x03e10081,0x7e084a0f,0x02e80f00,0xfe000e00,
0x02c88f00,0x7c046220,0x02c81f01,0xff00c240,
0x02c89f01,0xfe04c260,0x00a50080,0x7c00aa00,
0x01c10000,0x0400760f,0x00a58000,0x0404622f,
0x00a50001,0x0308e24f,0x00658001,0x020c626f,
0x00c10080,0x0500ea0f,0x02c41f00,0x0000620f,
0x00c18000,0xfe04c22f,0x01e10001,0x0008624f,
0x01a18001,0x000c666f,0x00a18081,0xfe0ce66f,
0x00e10001,0x7f08620f,0x02048000,0x03046a2f,
0x02c41f01,0x06086a4f,0x02c49f01,0x060c6a6f,
0x02e00f80,0xfe000220,0x02c08f00,0xfe040200,
0x02e08f01,0xfe0c0240,0x02c01f80,0xfe080260,
0x8aa480ad,0x2bfc5ca6,0xb5e05b5b,0xd48dc71c
0x00000000, 0x00008009, 0x20000000, 0x0000eca1,
0x00c00000, 0x88068093, 0x01400200, 0x9a048013,
0x9c000000, 0x000044a0, 0x3c200000, 0x88060094,
0x02400000, 0x88062014, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x0765a101, 0x9000e00f, 0x0761a101, 0x9000e02f,
0x03001f00, 0x900c8040, 0x03041f80, 0x900c8060,
0x076da101, 0x9000e04f, 0x0769a181, 0x9000e06f,
0x0745a101, 0x9000c00f, 0x0741a181, 0x9000c02f,
0x074da101, 0x9000c04f, 0x0749a181, 0x9000c06f,
0x0bc9a000, 0x7f00e20f, 0x0bc92080, 0x7f04e22f,
0x0bc9a001, 0x7f08e24f, 0x0bc92081, 0x7f0ce26f,
0x0725a101, 0x9000a00f, 0x0721a181, 0x9000a02f,
0x072da101, 0x9000a04f, 0x0729a181, 0x9000a06f,
0x0ac9a000, 0x7e00c20f, 0x0ac92080, 0x7e04c22f,
0x0ac9a001, 0x7e08c24f, 0x0ac92081, 0x7e0cc26f,
0x0ba5a000, 0x7f00e20f, 0x0ba52080, 0x7f04e22f,
0x0ba5a001, 0x7f08e24f, 0x0ba52081, 0x7f0ce26f,
0x08eda000, 0x9000800f, 0x08ed2080, 0x9000802f,
0x08eda001, 0x9000804f, 0x08ed2081, 0x9000806f,
0x09c9a000, 0x7d00a20f, 0x09c92080, 0x7d04a22f,
0x09c9a001, 0x7d08a24f, 0x09c92081, 0x7d0ca26f,
0x0aa5a000, 0x7e00c20f, 0x0aa52080, 0x7e04c22f,
0x0aa5a001, 0x7e08c24f, 0x0aa52081, 0x7e0cc26f,
0x0b81a000, 0x7f006200, 0x0b812080, 0x7f046220,
0x0b81a001, 0x7f080240, 0x0b812081, 0x7f0c0260,
0x08c9a000, 0x7c00820f, 0x08c92080, 0x7c04822f,
0x08c9a001, 0x7c08824f, 0x08c92081, 0x7c0c826f,
0x09a5a000, 0x7d00a20f, 0x09a52080, 0x7d04a22f,
0x09a5a001, 0x7d08a24f, 0x09a52081, 0x7d0ca26f,
0x0a81a000, 0x7e008200, 0x0a812080, 0x7e048220,
0x0a81a001, 0x7e086240, 0x0a812081, 0x7e0c4260,
0x0340a001, 0x9000c00f, 0x0344a001, 0x9000c02f,
0x0048a001, 0x9000c04f, 0x004ca001, 0x9000c06f,
0x0364a081, 0x9000e02f, 0x0360a001, 0x9000e00f,
0x0324a001, 0x90000020, 0x0068a001, 0x9000e04f,
0x006ca001, 0x9000e06f, 0x0320a081, 0x90000000,
0x08a5a000, 0x7c00820f, 0x08a52080, 0x7c04822f,
0x08a5a001, 0x7c08824f, 0x08a52081, 0x7c0c826f,
0x0981a000, 0x7d00a200, 0x09812080, 0x7d04a220,
0x0981a001, 0x7d08a240, 0x09812081, 0x7d0c6260,
0x02890000, 0x7e00c20f, 0x02898000, 0x7e04c22f,
0x0028a001, 0x9000a04f, 0x002ca001, 0x9000c06f,
0x02498081, 0x7e0caa6f, 0x03890000, 0x7f00e20f,
0x03898000, 0x7f04e22f, 0x02690001, 0x7e08f64f,
0x03498001, 0x7f0ce26f, 0x03690081, 0x7f08ca4f,
0x0881a000, 0x7c00c200, 0x08812080, 0x7c04c220,
0x0881a001, 0x7c08e240, 0x08812081, 0x7c0ca260,
0x0300a001, 0x9000800f, 0x0304a001, 0x9000802f,
0x0008a001, 0x9000804f, 0x000ca001, 0x9000806f,
0x01898080, 0x0004aa2f, 0x01890000, 0x0000a20f,
0x02a58000, 0x7e04c22f, 0x01690001, 0x7d08a24f,
0x01498081, 0x7e0cc26f, 0x02a50000, 0x7e00f60f,
0x03a58000, 0x7f04622f, 0x02a50001, 0x7f08e24f,
0x02658001, 0x7d0ca26f, 0x03a50080, 0x7f00ca0f,
0x00890000, 0x7c00820f, 0x00898000, 0x7c049220,
0x03a50001, 0x7e08c24f, 0x03658001, 0x7f0ce26f,
0x03c18080, 0xfe04862f, 0x01a50000, 0x7d008200,
0x01a58000, 0x7d04622f, 0x00690001, 0x7c086240,
0x00498081, 0x7c0c4260, 0x02c10000, 0x7f00e20f,
0x02c18000, 0x7e04c62f, 0x01a50001, 0x7d080240,
0x01658001, 0x7e0c0260, 0x01c18080, 0xfe040620,
0x03c10000, 0x7e00620f, 0x03a18001, 0x7f0c622f,
0x02e10001, 0x7f08764f, 0x02a18001, 0x7d0c766f,
0x03e10081, 0x7e084a0f, 0x02e80f00, 0xfe000e00,
0x02c88f00, 0x7c046220, 0x02c81f01, 0xff00c240,
0x02c89f01, 0xfe04c260, 0x00a50080, 0x7c00aa00,
0x01c10000, 0x0400760f, 0x00a58000, 0x0404622f,
0x00a50001, 0x0308e24f, 0x00658001, 0x020c626f,
0x00c10080, 0x0500ea0f, 0x02c41f00, 0x0000620f,
0x00c18000, 0xfe04c22f, 0x01e10001, 0x0008624f,
0x01a18001, 0x000c666f, 0x00a18081, 0xfe0ce66f,
0x00e10001, 0x7f08620f, 0x02048000, 0x03046a2f,
0x02c41f01, 0x06086a4f, 0x02c49f01, 0x060c6a6f,
0x02e00f80, 0xfe000220, 0x02c08f00, 0xfe040200,
0x02e08f01, 0xfe0c0240, 0x02c01f80, 0xfe080260,
0x8aa480ad, 0x2bfc5ca6, 0xb5e05b5b, 0xd48dc71c
};
static const uint32_t cpVertexShaderRegs[] = {
0x00000108,0x00000000,0x00000004,0x00000001,
0xff000201,0xffffffff,0xffffffff,0xffffffff,
0xffffffff,0xffffffff,0xffffffff,0xffffffff,
0xffffffff,0xffffffff,0x00000000,0xfffffff8,
0x00000003,0x00000001,0x00000000,0x00000002,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x00000000,0x0000000e,0x00000010
0x00000108, 0x00000000, 0x00000004, 0x00000001,
0xff000201, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0x00000000, 0xfffffff8,
0x00000003, 0x00000001, 0x00000000, 0x00000002,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x00000000, 0x0000000e, 0x00000010
};
static const uint32_t cpPixelShaderProgram[] = {
0x20000000,0x000008a4,0x04000000,0x01004085,
0x23000000,0x0000eca1,0x9f000000,0x0000e0a8,
0xd8000000,0x000000a4,0x07000000,0x01004085,
0xd9000000,0x000048a8,0xec000000,0x000000a4,
0x0a000000,0x01004085,0xed000000,0x000050a8,
0x02010000,0x000030a0,0x00000000,0x88062094,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0xfd001f80,0x900c0060,0x0000803f,0x00000000,
0x03011f80,0x8c210000,0xfd001f00,0x900c0000,
0xfd001f00,0x900ca02f,0x00000002,0x80020040,
0x00048002,0x80020060,0xf8001f80,0x900cc04f,
0x0000803f,0x00000000,0xfea81f00,0x9000e00f,
0xfeac1f00,0x9000e02f,0xf8001f00,0x900c804f,
0xf8001f80,0x900ca06f,0x00000040,0x00000000,
0xfea01f00,0x00280000,0xfea41f00,0x00280020,
0xfe041f00,0x00280040,0xfd041f80,0x00280060,
0xaf67bb3e,0x00000080,0x7fc41f00,0x00000000,
0x7fc01f80,0x00000020,0xfe041f00,0x100ac00f,
0xfe001f80,0x100ac02f,0xfea01f00,0x00280000,
0xfea41f00,0x00280020,0xfe041f00,0x00280040,
0xfd041f00,0x1028e06f,0x7fc01f82,0x00000000,
0x8c65583e,0x00000080,0x7ea41f00,0x80000000,
0x7ea01f00,0x80000020,0xfee01f00,0x10006040,
0x7fc48f82,0x00000860,0xa7c4623b,0x00000000,
0xfea81f00,0x1000e00f,0x7fcc9f01,0x10006020,
0xfe001f00,0x000a0040,0xfe041f00,0x000a0060,
0xfea89f80,0x10008040,0x8c65583e,0x3acd13bf,
0xfeb81f00,0x7e04c20f,0xfebc1f00,0x7e00822f,
0x03c89f00,0x80060040,0xfea49f00,0x1000e06f,
0xfea41f81,0x10006060,0x00809043,0x8c65583e,
0x3acd13bf,0x00000000,0xfea81f00,0xf880a30f,
0xfe001f00,0x900ca02f,0x7dc41f00,0x1000e04f,
0xfe081f00,0xfd80636f,0x04081f80,0x900c800f,
0x0000803f,0x00000000,0xfea81f00,0xf900620f,
0xfea41f00,0xf900622f,0xfe0c1f00,0x900ca04f,
0xfec00f00,0x1000c46f,0xfefc0f80,0x10006000,
0x00000842,0x00000000,0xfeac1f00,0xf900620f,
0x7fc81f00,0x9000c02f,0x7dc49f00,0x9000e04f,
0x7df08f01,0x10008060,0x030c1f80,0x900ca02f,
0x00000842,0x00000000,0xfea41f00,0x80000000,
0x7ecc1f00,0x9000e02f,0x7e688000,0x80000040,
0xfea81f00,0x80000060,0x7d6c8081,0x80000000,
0xa7c4623b,0x00000000,0xfe001f00,0x000a0000,
0xfe0c1f00,0x000a0020,0xfea41f00,0x80000040,
0x03648000,0xfe08626f,0x7d648081,0xff00420f,
0xa7c4623b,0x00000000,0xfeb01f00,0x7e04620f,
0xfeb41f00,0x7f08662f,0x7c800001,0xff006e4f,
0xfe081f00,0x000a0060,0x03680081,0xfe0c4e0f,
0x00809043,0x00000000,0xfebc1f00,0x7f04620f,
0x7cc41f00,0x00000020,0x7cc49f00,0x1000e04f,
0xff901f00,0x00000060,0xfe981f80,0x00000000,
0x00809043,0x00000000,0xfea81f00,0xf900620f,
0x7cc41f00,0x00000020,0x00c09f00,0x1000c04f,
0xfe0c1f00,0x80010060,0xff001f80,0x80010000,
0x00000842,0x00000000,0xfea81f00,0xf900620f,
0xfecc9f01,0x80000020,0x7fc81f00,0x9000e04f,
0x7dc89f00,0x1000c86f,0xffe01f80,0x80000000,
0x00000842,0x00000000,0xfeac1f00,0xf900620f,
0x7ec81f00,0x9000802f,0xfec49f00,0x9000a040,
0xfea89f00,0x80000060,0xffe01f80,0x9000a060,
0x00000842,0xa7c4623b,0xfea41f00,0x80000000,
0x7ecc1f00,0x9000e02f,0xfe0c1f00,0x000a0040,
0x7c888081,0x80000000,0xa7c4623b,0x00000000,
0xfe001f00,0x000a0000,0xfeb81f00,0x7f08622f,
0xfea49f00,0x80000040,0x048c8081,0xff00420f,
0x00809043,0xa7c4623b,0xfeb01f00,0x7c04620f,
0x03600000,0xff00622f,0xfea49f00,0x80000040,
0xfe081f80,0x000a0060,0x00809043,0x0ccec73c,
0xfebc1f00,0x7f040200,0xfea09f00,0x90000020,
0xfe941f00,0x10000040,0xfe081f80,0x30080060,
0x00809043,0x0ccec73c,0x00041f00,0x20080000,
0x00a01f00,0x80000020,0x002c1f02,0x1000e04f,
0x00081f80,0x80010060,0x0ccec73c,0x00000000,
0xfe201f02,0x1000800f,0xfec81f03,0x80020020,
0xfe041f00,0x20080040,0xfe881f00,0x00000060,
0xfecc9f81,0x9000a06f,0xfe0c1f00,0x000a0000,
0xfe801f00,0x00000020,0xfec01f02,0x80020040,
0xfe281f02,0x1000c06f,0xfe841f82,0x1000804f,
0xfe041f00,0x000a0000,0x7fc81f02,0x00000020,
0xfe8c1f00,0x00000040,0xfecc9f03,0x80020060,
0xfe881f82,0x1000a00f,0x7cc01f02,0x00000000,
0xfe8c1f02,0x1000e02f,0xfec49f00,0x80000040,
0xfe081f00,0x000a0060,0x03c89f80,0x9000e04f,
0x7ecc9f03,0x00000000,0xfec01f00,0x80000020,
0x04c81f00,0x80000040,0x7c880f01,0xfe086a6f,
0x7dac8f81,0x9000800f,0x7da00f00,0xfe04620f,
0xfec01f00,0x80000020,0x03c01f00,0x80000840,
0x03ac0f00,0xfe08c66f,0xfebc9f80,0xfd00420f,
0xe07be53f,0x5c8e5a3f,0xfeb09f00,0xfd00620f,
0x05e81f00,0x9000f02f,0x7fe48f00,0xfe04624f,
0x04ec8f00,0xfe08626f,0x03840f81,0x7f08a20f,
0xe07be53f,0x5c8e5a3f,0x7e0c1f00,0x900ce00f,
0xfe0c1f00,0x900c802f,0x05cc1f00,0x9000e84f,
0xfeb89f80,0xfd00626f,0xe07be53f,0x5c8e5a3f,
0x7cc09f81,0x80000020,0x7fa40f00,0x00280000,
0xfe848f00,0x00280020,0x7fe80f00,0x00280440,
0xfd001f80,0x00280060,0x00000080,0x00000000,
0xfdc01f80,0xf800620f,0x00000243,0x00000000,
0xfea01f80,0x90000060,0x5555d53f,0x00000000,
0x02011f80,0x8c110000,0x02448002,0x80020000,
0xf8402000,0x9006a02f,0x02552081,0x00000040,
0xfe301f00,0x1000e06f,0xfe081f80,0x1033c02f,
0xfe4c2081,0x80060040,0xfee88f81,0x0289e32f,
0x02c59f80,0x80060000,0xfee08f80,0x0285636f,
0xfecc8f80,0x80000000,0xfe40a081,0x80000060,
0x00cc9f81,0x9000e04f,0xfe281f00,0x80060000,
0xf8c01f81,0x9006c02f,0xfee00f81,0xfd80636f,
0x0000803f,0x00000000,0x7ec49f81,0xf880e34f,
0xfe381f80,0x00000000,0x7de40f81,0xfe800360,
0x00011f80,0x8c100000,0xf8001f00,0x900ce00f,
0x00311f00,0x1000e02f,0x02a41f00,0xf910624f,
0x02a01f00,0xf910626f,0x00011f80,0x1033e04f,
0x00000040,0x00000000,0xfecc9f03,0x80020000,
0xfec81f83,0x80020060,0x7fd49f01,0x00000020,
0x7fd41f80,0x00000040,0xfe081f00,0x80010000,
0xfe041f80,0x80010060,0xfee00f01,0x80000000,
0xfeec0f81,0x80000020,0xfec01f00,0x00280000,
0xfec49f00,0x00280020,0x7fe00f00,0x00280040,
0xfd001f80,0x00280060,0x00000080,0x00000000,
0xfe001f80,0x00350000,0x00ec1f82,0x000c0260,
0x01011f00,0x800c0000,0x01051f00,0x800c0020,
0x002c1f00,0x80060040,0xf8008001,0x9006e06f,
0x01091f80,0x800c0000,0x01c01f00,0x90000000,
0xfe088001,0xfd80632f,0x01e81f00,0x90000040,
0x01c49f80,0x90000020,0x0000803f,0x00000000,
0x7fcc9f80,0xf880630f,0xfe20a081,0x80000000,
0x01cc1f80,0x90000060,0xc21e82a7,0x62ccc547,
0x1708607c,0x73ea57a6
0x20000000, 0x000008a4, 0x04000000, 0x01004085,
0x23000000, 0x0000eca1, 0x9f000000, 0x0000e0a8,
0xd8000000, 0x000000a4, 0x07000000, 0x01004085,
0xd9000000, 0x000048a8, 0xec000000, 0x000000a4,
0x0a000000, 0x01004085, 0xed000000, 0x000050a8,
0x02010000, 0x000030a0, 0x00000000, 0x88062094,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xfd001f80, 0x900c0060, 0x0000803f, 0x00000000,
0x03011f80, 0x8c210000, 0xfd001f00, 0x900c0000,
0xfd001f00, 0x900ca02f, 0x00000002, 0x80020040,
0x00048002, 0x80020060, 0xf8001f80, 0x900cc04f,
0x0000803f, 0x00000000, 0xfea81f00, 0x9000e00f,
0xfeac1f00, 0x9000e02f, 0xf8001f00, 0x900c804f,
0xf8001f80, 0x900ca06f, 0x00000040, 0x00000000,
0xfea01f00, 0x00280000, 0xfea41f00, 0x00280020,
0xfe041f00, 0x00280040, 0xfd041f80, 0x00280060,
0xaf67bb3e, 0x00000080, 0x7fc41f00, 0x00000000,
0x7fc01f80, 0x00000020, 0xfe041f00, 0x100ac00f,
0xfe001f80, 0x100ac02f, 0xfea01f00, 0x00280000,
0xfea41f00, 0x00280020, 0xfe041f00, 0x00280040,
0xfd041f00, 0x1028e06f, 0x7fc01f82, 0x00000000,
0x8c65583e, 0x00000080, 0x7ea41f00, 0x80000000,
0x7ea01f00, 0x80000020, 0xfee01f00, 0x10006040,
0x7fc48f82, 0x00000860, 0xa7c4623b, 0x00000000,
0xfea81f00, 0x1000e00f, 0x7fcc9f01, 0x10006020,
0xfe001f00, 0x000a0040, 0xfe041f00, 0x000a0060,
0xfea89f80, 0x10008040, 0x8c65583e, 0x3acd13bf,
0xfeb81f00, 0x7e04c20f, 0xfebc1f00, 0x7e00822f,
0x03c89f00, 0x80060040, 0xfea49f00, 0x1000e06f,
0xfea41f81, 0x10006060, 0x00809043, 0x8c65583e,
0x3acd13bf, 0x00000000, 0xfea81f00, 0xf880a30f,
0xfe001f00, 0x900ca02f, 0x7dc41f00, 0x1000e04f,
0xfe081f00, 0xfd80636f, 0x04081f80, 0x900c800f,
0x0000803f, 0x00000000, 0xfea81f00, 0xf900620f,
0xfea41f00, 0xf900622f, 0xfe0c1f00, 0x900ca04f,
0xfec00f00, 0x1000c46f, 0xfefc0f80, 0x10006000,
0x00000842, 0x00000000, 0xfeac1f00, 0xf900620f,
0x7fc81f00, 0x9000c02f, 0x7dc49f00, 0x9000e04f,
0x7df08f01, 0x10008060, 0x030c1f80, 0x900ca02f,
0x00000842, 0x00000000, 0xfea41f00, 0x80000000,
0x7ecc1f00, 0x9000e02f, 0x7e688000, 0x80000040,
0xfea81f00, 0x80000060, 0x7d6c8081, 0x80000000,
0xa7c4623b, 0x00000000, 0xfe001f00, 0x000a0000,
0xfe0c1f00, 0x000a0020, 0xfea41f00, 0x80000040,
0x03648000, 0xfe08626f, 0x7d648081, 0xff00420f,
0xa7c4623b, 0x00000000, 0xfeb01f00, 0x7e04620f,
0xfeb41f00, 0x7f08662f, 0x7c800001, 0xff006e4f,
0xfe081f00, 0x000a0060, 0x03680081, 0xfe0c4e0f,
0x00809043, 0x00000000, 0xfebc1f00, 0x7f04620f,
0x7cc41f00, 0x00000020, 0x7cc49f00, 0x1000e04f,
0xff901f00, 0x00000060, 0xfe981f80, 0x00000000,
0x00809043, 0x00000000, 0xfea81f00, 0xf900620f,
0x7cc41f00, 0x00000020, 0x00c09f00, 0x1000c04f,
0xfe0c1f00, 0x80010060, 0xff001f80, 0x80010000,
0x00000842, 0x00000000, 0xfea81f00, 0xf900620f,
0xfecc9f01, 0x80000020, 0x7fc81f00, 0x9000e04f,
0x7dc89f00, 0x1000c86f, 0xffe01f80, 0x80000000,
0x00000842, 0x00000000, 0xfeac1f00, 0xf900620f,
0x7ec81f00, 0x9000802f, 0xfec49f00, 0x9000a040,
0xfea89f00, 0x80000060, 0xffe01f80, 0x9000a060,
0x00000842, 0xa7c4623b, 0xfea41f00, 0x80000000,
0x7ecc1f00, 0x9000e02f, 0xfe0c1f00, 0x000a0040,
0x7c888081, 0x80000000, 0xa7c4623b, 0x00000000,
0xfe001f00, 0x000a0000, 0xfeb81f00, 0x7f08622f,
0xfea49f00, 0x80000040, 0x048c8081, 0xff00420f,
0x00809043, 0xa7c4623b, 0xfeb01f00, 0x7c04620f,
0x03600000, 0xff00622f, 0xfea49f00, 0x80000040,
0xfe081f80, 0x000a0060, 0x00809043, 0x0ccec73c,
0xfebc1f00, 0x7f040200, 0xfea09f00, 0x90000020,
0xfe941f00, 0x10000040, 0xfe081f80, 0x30080060,
0x00809043, 0x0ccec73c, 0x00041f00, 0x20080000,
0x00a01f00, 0x80000020, 0x002c1f02, 0x1000e04f,
0x00081f80, 0x80010060, 0x0ccec73c, 0x00000000,
0xfe201f02, 0x1000800f, 0xfec81f03, 0x80020020,
0xfe041f00, 0x20080040, 0xfe881f00, 0x00000060,
0xfecc9f81, 0x9000a06f, 0xfe0c1f00, 0x000a0000,
0xfe801f00, 0x00000020, 0xfec01f02, 0x80020040,
0xfe281f02, 0x1000c06f, 0xfe841f82, 0x1000804f,
0xfe041f00, 0x000a0000, 0x7fc81f02, 0x00000020,
0xfe8c1f00, 0x00000040, 0xfecc9f03, 0x80020060,
0xfe881f82, 0x1000a00f, 0x7cc01f02, 0x00000000,
0xfe8c1f02, 0x1000e02f, 0xfec49f00, 0x80000040,
0xfe081f00, 0x000a0060, 0x03c89f80, 0x9000e04f,
0x7ecc9f03, 0x00000000, 0xfec01f00, 0x80000020,
0x04c81f00, 0x80000040, 0x7c880f01, 0xfe086a6f,
0x7dac8f81, 0x9000800f, 0x7da00f00, 0xfe04620f,
0xfec01f00, 0x80000020, 0x03c01f00, 0x80000840,
0x03ac0f00, 0xfe08c66f, 0xfebc9f80, 0xfd00420f,
0xe07be53f, 0x5c8e5a3f, 0xfeb09f00, 0xfd00620f,
0x05e81f00, 0x9000f02f, 0x7fe48f00, 0xfe04624f,
0x04ec8f00, 0xfe08626f, 0x03840f81, 0x7f08a20f,
0xe07be53f, 0x5c8e5a3f, 0x7e0c1f00, 0x900ce00f,
0xfe0c1f00, 0x900c802f, 0x05cc1f00, 0x9000e84f,
0xfeb89f80, 0xfd00626f, 0xe07be53f, 0x5c8e5a3f,
0x7cc09f81, 0x80000020, 0x7fa40f00, 0x00280000,
0xfe848f00, 0x00280020, 0x7fe80f00, 0x00280440,
0xfd001f80, 0x00280060, 0x00000080, 0x00000000,
0xfdc01f80, 0xf800620f, 0x00000243, 0x00000000,
0xfea01f80, 0x90000060, 0x5555d53f, 0x00000000,
0x02011f80, 0x8c110000, 0x02448002, 0x80020000,
0xf8402000, 0x9006a02f, 0x02552081, 0x00000040,
0xfe301f00, 0x1000e06f, 0xfe081f80, 0x1033c02f,
0xfe4c2081, 0x80060040, 0xfee88f81, 0x0289e32f,
0x02c59f80, 0x80060000, 0xfee08f80, 0x0285636f,
0xfecc8f80, 0x80000000, 0xfe40a081, 0x80000060,
0x00cc9f81, 0x9000e04f, 0xfe281f00, 0x80060000,
0xf8c01f81, 0x9006c02f, 0xfee00f81, 0xfd80636f,
0x0000803f, 0x00000000, 0x7ec49f81, 0xf880e34f,
0xfe381f80, 0x00000000, 0x7de40f81, 0xfe800360,
0x00011f80, 0x8c100000, 0xf8001f00, 0x900ce00f,
0x00311f00, 0x1000e02f, 0x02a41f00, 0xf910624f,
0x02a01f00, 0xf910626f, 0x00011f80, 0x1033e04f,
0x00000040, 0x00000000, 0xfecc9f03, 0x80020000,
0xfec81f83, 0x80020060, 0x7fd49f01, 0x00000020,
0x7fd41f80, 0x00000040, 0xfe081f00, 0x80010000,
0xfe041f80, 0x80010060, 0xfee00f01, 0x80000000,
0xfeec0f81, 0x80000020, 0xfec01f00, 0x00280000,
0xfec49f00, 0x00280020, 0x7fe00f00, 0x00280040,
0xfd001f80, 0x00280060, 0x00000080, 0x00000000,
0xfe001f80, 0x00350000, 0x00ec1f82, 0x000c0260,
0x01011f00, 0x800c0000, 0x01051f00, 0x800c0020,
0x002c1f00, 0x80060040, 0xf8008001, 0x9006e06f,
0x01091f80, 0x800c0000, 0x01c01f00, 0x90000000,
0xfe088001, 0xfd80632f, 0x01e81f00, 0x90000040,
0x01c49f80, 0x90000020, 0x0000803f, 0x00000000,
0x7fcc9f80, 0xf880630f, 0xfe20a081, 0x80000000,
0x01cc1f80, 0x90000060, 0xc21e82a7, 0x62ccc547,
0x1708607c, 0x73ea57a6
};
static const uint32_t cpPixelShaderRegs[] = {
0x00000106,0x00000002,0x14000003,0x00000000,
0x00000003,0x00000100,0x00000101,0x00000102,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x0000000f,0x00000001,0x00000010,
0x00000000
0x00000106, 0x00000002, 0x14000003, 0x00000000,
0x00000003, 0x00000100, 0x00000101, 0x00000102,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x0000000f, 0x00000001, 0x00000010,
0x00000000
};
ShaderFractalColor * ShaderFractalColor::shaderInstance = NULL;
ShaderFractalColor *ShaderFractalColor::shaderInstance = NULL;
ShaderFractalColor::ShaderFractalColor()
: vertexShader(cuAttributeCount) {
: vertexShader(cuAttributeCount) {
//! create pixel shader
pixelShader.setProgram(cpPixelShaderProgram, sizeof(cpPixelShaderProgram), cpPixelShaderRegs, sizeof(cpPixelShaderRegs));
@ -290,16 +290,16 @@ ShaderFractalColor::ShaderFractalColor()
fadeOutLocation = 8;
fractalLocation = 12;
pixelShader.addUniformVar((GX2UniformVar) {
"unf_blur_border", GX2_SHADER_VAR_TYPE_FLOAT, 1, blurLocation, -1
"unf_blur_border", GX2_SHADER_VAR_TYPE_FLOAT, 1, blurLocation, -1
});
pixelShader.addUniformVar((GX2UniformVar) {
"unf_color_intensity", GX2_SHADER_VAR_TYPE_FLOAT4, 1, colorIntensityLocation, -1
"unf_color_intensity", GX2_SHADER_VAR_TYPE_FLOAT4, 1, colorIntensityLocation, -1
});
pixelShader.addUniformVar((GX2UniformVar) {
"unf_fade_out_alpha", GX2_SHADER_VAR_TYPE_FLOAT4, 1, fadeOutLocation, -1
"unf_fade_out_alpha", GX2_SHADER_VAR_TYPE_FLOAT4, 1, fadeOutLocation, -1
});
pixelShader.addUniformVar((GX2UniformVar) {
"unf_fract_alpha", GX2_SHADER_VAR_TYPE_INT, 1, fractalLocation, -1
"unf_fract_alpha", GX2_SHADER_VAR_TYPE_INT, 1, fractalLocation, -1
});
//! create vertex shader
vertexShader.setProgram(cpVertexShaderProgram, sizeof(cpVertexShaderProgram), cpVertexShaderRegs, sizeof(cpVertexShaderRegs));
@ -308,26 +308,26 @@ ShaderFractalColor::ShaderFractalColor()
projectionMatrixLocation = 16;
viewMatrixLocation = 32;
vertexShader.addUniformVar((GX2UniformVar) {
"modelMatrix", GX2_SHADER_VAR_TYPE_MATRIX4X4, 1, modelMatrixLocation, -1
"modelMatrix", GX2_SHADER_VAR_TYPE_MATRIX4X4, 1, modelMatrixLocation, -1
});
vertexShader.addUniformVar((GX2UniformVar) {
"projectionMatrix", GX2_SHADER_VAR_TYPE_MATRIX4X4, 1, projectionMatrixLocation, -1
"projectionMatrix", GX2_SHADER_VAR_TYPE_MATRIX4X4, 1, projectionMatrixLocation, -1
});
vertexShader.addUniformVar((GX2UniformVar) {
"viewMatrix", GX2_SHADER_VAR_TYPE_MATRIX4X4, 1, viewMatrixLocation, -1
"viewMatrix", GX2_SHADER_VAR_TYPE_MATRIX4X4, 1, viewMatrixLocation, -1
});
positionLocation = 0;
colorLocation = 1;
texCoordLocation = 2;
vertexShader.addAttribVar((GX2AttribVar) {
"attr_colors", GX2_SHADER_VAR_TYPE_FLOAT4, 0, colorLocation
"attr_colors", GX2_SHADER_VAR_TYPE_FLOAT4, 0, colorLocation
});
vertexShader.addAttribVar((GX2AttribVar) {
"attr_position", GX2_SHADER_VAR_TYPE_FLOAT3, 0, positionLocation
"attr_position", GX2_SHADER_VAR_TYPE_FLOAT3, 0, positionLocation
});
vertexShader.addAttribVar((GX2AttribVar) {
"attr_texture_coord", GX2_SHADER_VAR_TYPE_FLOAT2, 0, texCoordLocation
"attr_texture_coord", GX2_SHADER_VAR_TYPE_FLOAT2, 0, texCoordLocation
});
//! setup attribute streams
@ -340,23 +340,23 @@ ShaderFractalColor::ShaderFractalColor()
//! initialize default quad texture vertexes as those are very commonly used
//! model vertex has to be align and cannot be in unknown regions for GX2 like 0xBCAE1000
posVtxs = (float*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciPositionVtxsSize);
texCoords = (float*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciTexCoordsVtxsSize);
colorVtxs = (uint8_t*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciColorVtxsSize);
posVtxs = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciPositionVtxsSize);
texCoords = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciTexCoordsVtxsSize);
colorVtxs = (uint8_t *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciColorVtxsSize);
//! position vertex structure and texture coordinate vertex structure
int32_t i = 0;
posVtxs[i++] = -1.0f;
posVtxs[i++] = -1.0f;
posVtxs[i++] = 0.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = -1.0f;
posVtxs[i++] = 0.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 0.0f;
posVtxs[i++] = -1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 0.0f;
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, posVtxs, ciPositionVtxsSize);
@ -372,22 +372,22 @@ ShaderFractalColor::ShaderFractalColor()
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, texCoords, ciTexCoordsVtxsSize);
for(i = 0; i < (int32_t)ciColorVtxsSize; i++)
for (i = 0; i < (int32_t) ciColorVtxsSize; i++)
colorVtxs[i] = 0xff;
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, colorVtxs, ciColorVtxsSize);
}
ShaderFractalColor::~ShaderFractalColor() {
if(posVtxs) {
if (posVtxs) {
free(posVtxs);
posVtxs = NULL;
}
if(texCoords) {
if (texCoords) {
free(texCoords);
texCoords = NULL;
}
if(colorVtxs) {
if (colorVtxs) {
free(colorVtxs);
colorVtxs = NULL;
}

362
source/video/shaders/Texture2DShader.cpp
View File

@ -19,198 +19,198 @@
#include <gui/video/shaders/Texture2DShader.h>
static const uint32_t cpVertexShaderProgram[] = {
0x00000000,0x00008009,0x20000000,0x000080a0,
0x3c200100,0x88060094,0x00400000,0x88042014,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x02290001,0x80000000,0x02041f00,0x900c0020,
0x00a11f00,0xfc00624f,0xfd041f00,0x900c4060,
0x02001f80,0x900c0000,0x83f9223e,0x0000803f,
0xfe081f00,0x00080020,0xfe202081,0x10004040,
0xfea49f80,0xfd00620f,0xdb0f49c0,0xdb0fc940,
0xfea01f80,0x9000e06f,0x83f9223e,0x00000000,
0xfe0c1f80,0x00370000,0xffa01f00,0x80000040,
0xff101f00,0x800c0060,0x7f0c1f80,0x80370040,
0x0000103f,0x00000000,0xffa01f00,0x80000000,
0xff001f00,0x800c0020,0x02c51f01,0x80000040,
0xfeac9f80,0x80000060,0x0000103f,0x398ee33f,
0xfea01f00,0x80000000,0x02c19f01,0x9000e02f,
0x01c41f01,0x9000e04f,0x02c59f80,0x80000060,
0x398ee33f,0x00000000,0x01c49f01,0x80000020,
0x02c11f80,0x80000040,0x01e08f00,0xfe04624f,
0x01c01f81,0x7f08626f,0xfe2c2000,0x10004000,
0xfe28a080,0x10004020,0xeb825790,0xb6f711be,
0x7c0e2df2,0x81173cfa
0x00000000, 0x00008009, 0x20000000, 0x000080a0,
0x3c200100, 0x88060094, 0x00400000, 0x88042014,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x02290001, 0x80000000, 0x02041f00, 0x900c0020,
0x00a11f00, 0xfc00624f, 0xfd041f00, 0x900c4060,
0x02001f80, 0x900c0000, 0x83f9223e, 0x0000803f,
0xfe081f00, 0x00080020, 0xfe202081, 0x10004040,
0xfea49f80, 0xfd00620f, 0xdb0f49c0, 0xdb0fc940,
0xfea01f80, 0x9000e06f, 0x83f9223e, 0x00000000,
0xfe0c1f80, 0x00370000, 0xffa01f00, 0x80000040,
0xff101f00, 0x800c0060, 0x7f0c1f80, 0x80370040,
0x0000103f, 0x00000000, 0xffa01f00, 0x80000000,
0xff001f00, 0x800c0020, 0x02c51f01, 0x80000040,
0xfeac9f80, 0x80000060, 0x0000103f, 0x398ee33f,
0xfea01f00, 0x80000000, 0x02c19f01, 0x9000e02f,
0x01c41f01, 0x9000e04f, 0x02c59f80, 0x80000060,
0x398ee33f, 0x00000000, 0x01c49f01, 0x80000020,
0x02c11f80, 0x80000040, 0x01e08f00, 0xfe04624f,
0x01c01f81, 0x7f08626f, 0xfe2c2000, 0x10004000,
0xfe28a080, 0x10004020, 0xeb825790, 0xb6f711be,
0x7c0e2df2, 0x81173cfa
};
static const uint32_t cpVertexShaderRegs[] = {
0x00000103,0x00000000,0x00000000,0x00000001,
0xffffff00,0xffffffff,0xffffffff,0xffffffff,
0xffffffff,0xffffffff,0xffffffff,0xffffffff,
0xffffffff,0xffffffff,0x00000000,0xfffffffc,
0x00000002,0x00000000,0x00000001,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x000000ff,0x000000ff,0x000000ff,
0x000000ff,0x00000000,0x0000000e,0x00000010
0x00000103, 0x00000000, 0x00000000, 0x00000001,
0xffffff00, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0x00000000, 0xfffffffc,
0x00000002, 0x00000000, 0x00000001, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
0x000000ff, 0x00000000, 0x0000000e, 0x00000010
};
static const uint32_t cPixelShaderProgram[] = {
0x20000000,0x00000ca4,0x0b000000,0x00000085,
0x24000000,0x000050a0,0xb0000000,0x000cc080,
0x39000000,0x00005ca0,0xb8000000,0x000cc080,
0x51000000,0x000078a0,0xc0000000,0x000cc080,
0x70000000,0x000064a0,0xc8000000,0x0008c080,
0x8a000000,0x00005ca0,0x0e000000,0x01008086,
0xce000000,0x0000c080,0xa2000000,0x00000ca8,
0x00800000,0x88062094,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00051f00,0x80060000,0x00011f80,0x80060040,
0xfec81f80,0xfb802320,0x01041f80,0x8c220000,
0x00a41f00,0xfc10620f,0x010d1f00,0x900c0021,
0x00091f00,0x80060040,0x00a01f80,0xfc10626f,
0x00000040,0x00000000,0xfe080000,0xfe8cc300,
0xfe088080,0xfe80c320,0x00a11f00,0xfe000200,
0x00a51f00,0xfe040220,0x00a19f00,0xfe000240,
0x00a59f00,0xfe040260,0x00a11f81,0xfe002600,
0x4260e5bc,0xa69bc4bc,0x0ad7a3bc,0x00000000,
0x00a11f00,0x06004200,0x00a59f00,0x06042220,
0x00a51f00,0x06044240,0x00a11f01,0x06008260,
0x00a51f81,0x06048620,0x6f1283bc,0x0ad7a3bc,
0xa69b44bc,0x00000000,0x00a41f00,0x80000000,
0x00a01f00,0x80000020,0x00ac1f00,0x80000040,
0x00a81f00,0x80000060,0x00a19f80,0x06000600,
0xcac3123c,0x6f1203bc,0x03a41f00,0xfe00620f,
0x03a01f00,0xfe04622f,0x03ac1f00,0xfe08624f,
0x03a81f00,0xfe0c626f,0x00a59f80,0x06040620,
0xcc28913b,0x6f1203bc,0x01a41f00,0xfe00620f,
0x01a01f00,0xfe04622f,0x01ac1f00,0xfe08624f,
0x01a81f00,0xfe0c626f,0x00a19f80,0x06002600,
0xe8eab03c,0x6f1283bb,0x02ac1f00,0xfe084200,
0x02a81f00,0xfe0c4220,0x02a41f00,0xfe004240,
0x02a01f00,0xfe044260,0x00a59f80,0x06042620,
0x92bb353d,0x6f1283bb,0x04a81f00,0x0204620f,
0x04ac1f00,0x0200662f,0x04a41f00,0x0208624f,
0x04a01f00,0x020c626f,0x00a19f80,0x06004600,
0xc4139f3d,0x6f12833b,0x00a41f00,0xfe08620f,
0x00a01f00,0xfe0c622f,0x00ac1f00,0xfe04624f,
0x00a81f00,0xfe00626f,0x00a59f80,0x06044620,
0xb950ed3d,0x6f12833b,0x01a41f00,0xfe00620f,
0x01a01f00,0xfe04622f,0x01ac1f00,0xfe08624f,
0x01a81f00,0xfe0c626f,0x00a19f80,0x06002600,
0xecd7163e,0x6f12033c,0x03a41f00,0xfe000200,
0x03a01f00,0xfe040220,0x03ac1f00,0xfe082240,
0x03a81f00,0xfe0c2260,0x00a59f80,0x06042620,
0x2168233e,0x6f12033c,0x00a11f00,0x06006200,
0x00a51f00,0x06046220,0x00a19f00,0x06006240,
0x00a59f00,0x06046260,0x00a11f81,0x0600e600,
0xa69b443c,0x6f12833c,0x0ad7a33c,0x00000000,
0x02ac1f00,0x0108620f,0x02a81f00,0x010c622f,
0x02a41f00,0x0000624f,0x02a01f00,0x0004666f,
0x00a59f80,0x0604e620,0xecd7163e,0x0ad7a33c,
0x04a81f00,0xfe04620f,0x04ac1f00,0xfe00622f,
0x04a41f00,0xfe08624f,0x04a01f00,0xfe0c626f,
0x00a19f80,0x06008600,0xb950ed3d,0xa69bc43c,
0x05a41f00,0xfe08620f,0x05a01f00,0xfe0c622f,
0x05ac1f00,0xfe04624f,0x05a81f00,0xfe00626f,
0x00a59f80,0x06048620,0xc4139f3d,0xa69bc43c,
0x03a41f00,0xfe00a200,0x03a01f00,0xfe04a220,
0x03ac1f00,0xfe086240,0x03a81f00,0xfe0c6260,
0x00a19f80,0x06006600,0x92bb353d,0x4260e53c,
0x00a51f80,0x06046220,0x4260e53c,0x00000000,
0x07ac1f00,0x0308620f,0x07a81f00,0x030c622f,
0x07a41f00,0x0500624f,0x07a01f80,0x0504626f,
0xe8eab03c,0x00000000,0x04a81f00,0xfe04620f,
0x04ac1f00,0xfe00622f,0x04a41f00,0xfe08624f,
0x04a01f80,0xfe0c626f,0xcac3123c,0x00000000,
0x06a41f00,0xfe08620f,0x06a01f00,0xfe0c622f,
0x06ac1f00,0xfe04624f,0x06a81f80,0xfe00626f,
0xcc28913b,0x00000000,0xfe20a000,0x9000e00f,
0xfe242000,0x9000e02f,0xfe28a001,0x9000e04f,
0xfe2c2081,0x9000e06f,0xfe28a081,0x80060020,
0xfee48f00,0x7f842300,0xfee40f00,0x7f802320,
0xfee48f01,0x7f8c2340,0xfee40f81,0x08842b60,
0x00202000,0x90002000,0x0024a000,0x90002020,
0x00282001,0x90002040,0x002ca081,0x90002060,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x10000000,0x03100df0,0x00008010,0xecdfea0d,
0x10000000,0x00100df0,0x0000a051,0xecdfea0d,
0x10000100,0x01100df0,0x00008010,0xecdfea0d,
0x10000200,0x02100df0,0x00000011,0xecdfea0d,
0x10000400,0x04100df0,0x0000b070,0xecdfea0d,
0x10000000,0x00100df0,0x00008010,0xecdfea0d,
0x10000100,0x01100df0,0x00008010,0xecdfea0d,
0x10000600,0x03100df0,0x00008010,0xecdfea0d,
0x10000200,0x02100df0,0x00008010,0xecdfea0d,
0x10000100,0x04100df0,0x00008010,0xecdfea0d,
0x10000300,0x05100df0,0x00008010,0xecdfea0d,
0x10000300,0x03100df0,0x0000a051,0xecdfea0d,
0x10000700,0x07100df0,0x00008010,0xecdfea0d,
0x10000400,0x04100df0,0x00008010,0xecdfea0d,
0x10000300,0x06100df0,0x00008010,0xecdfea0d,
0x10000000,0x00100df0,0x00008010,0xecdfea0d,
0xc8581837,0x22740275,0x281eddcc,0xfa8b9b65
0x20000000, 0x00000ca4, 0x0b000000, 0x00000085,
0x24000000, 0x000050a0, 0xb0000000, 0x000cc080,
0x39000000, 0x00005ca0, 0xb8000000, 0x000cc080,
0x51000000, 0x000078a0, 0xc0000000, 0x000cc080,
0x70000000, 0x000064a0, 0xc8000000, 0x0008c080,
0x8a000000, 0x00005ca0, 0x0e000000, 0x01008086,
0xce000000, 0x0000c080, 0xa2000000, 0x00000ca8,
0x00800000, 0x88062094, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00051f00, 0x80060000, 0x00011f80, 0x80060040,
0xfec81f80, 0xfb802320, 0x01041f80, 0x8c220000,
0x00a41f00, 0xfc10620f, 0x010d1f00, 0x900c0021,
0x00091f00, 0x80060040, 0x00a01f80, 0xfc10626f,
0x00000040, 0x00000000, 0xfe080000, 0xfe8cc300,
0xfe088080, 0xfe80c320, 0x00a11f00, 0xfe000200,
0x00a51f00, 0xfe040220, 0x00a19f00, 0xfe000240,
0x00a59f00, 0xfe040260, 0x00a11f81, 0xfe002600,
0x4260e5bc, 0xa69bc4bc, 0x0ad7a3bc, 0x00000000,
0x00a11f00, 0x06004200, 0x00a59f00, 0x06042220,
0x00a51f00, 0x06044240, 0x00a11f01, 0x06008260,
0x00a51f81, 0x06048620, 0x6f1283bc, 0x0ad7a3bc,
0xa69b44bc, 0x00000000, 0x00a41f00, 0x80000000,
0x00a01f00, 0x80000020, 0x00ac1f00, 0x80000040,
0x00a81f00, 0x80000060, 0x00a19f80, 0x06000600,
0xcac3123c, 0x6f1203bc, 0x03a41f00, 0xfe00620f,
0x03a01f00, 0xfe04622f, 0x03ac1f00, 0xfe08624f,
0x03a81f00, 0xfe0c626f, 0x00a59f80, 0x06040620,
0xcc28913b, 0x6f1203bc, 0x01a41f00, 0xfe00620f,
0x01a01f00, 0xfe04622f, 0x01ac1f00, 0xfe08624f,
0x01a81f00, 0xfe0c626f, 0x00a19f80, 0x06002600,
0xe8eab03c, 0x6f1283bb, 0x02ac1f00, 0xfe084200,
0x02a81f00, 0xfe0c4220, 0x02a41f00, 0xfe004240,
0x02a01f00, 0xfe044260, 0x00a59f80, 0x06042620,
0x92bb353d, 0x6f1283bb, 0x04a81f00, 0x0204620f,
0x04ac1f00, 0x0200662f, 0x04a41f00, 0x0208624f,
0x04a01f00, 0x020c626f, 0x00a19f80, 0x06004600,
0xc4139f3d, 0x6f12833b, 0x00a41f00, 0xfe08620f,
0x00a01f00, 0xfe0c622f, 0x00ac1f00, 0xfe04624f,
0x00a81f00, 0xfe00626f, 0x00a59f80, 0x06044620,
0xb950ed3d, 0x6f12833b, 0x01a41f00, 0xfe00620f,
0x01a01f00, 0xfe04622f, 0x01ac1f00, 0xfe08624f,
0x01a81f00, 0xfe0c626f, 0x00a19f80, 0x06002600,
0xecd7163e, 0x6f12033c, 0x03a41f00, 0xfe000200,
0x03a01f00, 0xfe040220, 0x03ac1f00, 0xfe082240,
0x03a81f00, 0xfe0c2260, 0x00a59f80, 0x06042620,
0x2168233e, 0x6f12033c, 0x00a11f00, 0x06006200,
0x00a51f00, 0x06046220, 0x00a19f00, 0x06006240,
0x00a59f00, 0x06046260, 0x00a11f81, 0x0600e600,
0xa69b443c, 0x6f12833c, 0x0ad7a33c, 0x00000000,
0x02ac1f00, 0x0108620f, 0x02a81f00, 0x010c622f,
0x02a41f00, 0x0000624f, 0x02a01f00, 0x0004666f,
0x00a59f80, 0x0604e620, 0xecd7163e, 0x0ad7a33c,
0x04a81f00, 0xfe04620f, 0x04ac1f00, 0xfe00622f,
0x04a41f00, 0xfe08624f, 0x04a01f00, 0xfe0c626f,
0x00a19f80, 0x06008600, 0xb950ed3d, 0xa69bc43c,
0x05a41f00, 0xfe08620f, 0x05a01f00, 0xfe0c622f,
0x05ac1f00, 0xfe04624f, 0x05a81f00, 0xfe00626f,
0x00a59f80, 0x06048620, 0xc4139f3d, 0xa69bc43c,
0x03a41f00, 0xfe00a200, 0x03a01f00, 0xfe04a220,
0x03ac1f00, 0xfe086240, 0x03a81f00, 0xfe0c6260,
0x00a19f80, 0x06006600, 0x92bb353d, 0x4260e53c,
0x00a51f80, 0x06046220, 0x4260e53c, 0x00000000,
0x07ac1f00, 0x0308620f, 0x07a81f00, 0x030c622f,
0x07a41f00, 0x0500624f, 0x07a01f80, 0x0504626f,
0xe8eab03c, 0x00000000, 0x04a81f00, 0xfe04620f,
0x04ac1f00, 0xfe00622f, 0x04a41f00, 0xfe08624f,
0x04a01f80, 0xfe0c626f, 0xcac3123c, 0x00000000,
0x06a41f00, 0xfe08620f, 0x06a01f00, 0xfe0c622f,
0x06ac1f00, 0xfe04624f, 0x06a81f80, 0xfe00626f,
0xcc28913b, 0x00000000, 0xfe20a000, 0x9000e00f,
0xfe242000, 0x9000e02f, 0xfe28a001, 0x9000e04f,
0xfe2c2081, 0x9000e06f, 0xfe28a081, 0x80060020,
0xfee48f00, 0x7f842300, 0xfee40f00, 0x7f802320,
0xfee48f01, 0x7f8c2340, 0xfee40f81, 0x08842b60,
0x00202000, 0x90002000, 0x0024a000, 0x90002020,
0x00282001, 0x90002040, 0x002ca081, 0x90002060,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x10000000, 0x03100df0, 0x00008010, 0xecdfea0d,
0x10000000, 0x00100df0, 0x0000a051, 0xecdfea0d,
0x10000100, 0x01100df0, 0x00008010, 0xecdfea0d,
0x10000200, 0x02100df0, 0x00000011, 0xecdfea0d,
0x10000400, 0x04100df0, 0x0000b070, 0xecdfea0d,
0x10000000, 0x00100df0, 0x00008010, 0xecdfea0d,
0x10000100, 0x01100df0, 0x00008010, 0xecdfea0d,
0x10000600, 0x03100df0, 0x00008010, 0xecdfea0d,
0x10000200, 0x02100df0, 0x00008010, 0xecdfea0d,
0x10000100, 0x04100df0, 0x00008010, 0xecdfea0d,
0x10000300, 0x05100df0, 0x00008010, 0xecdfea0d,
0x10000300, 0x03100df0, 0x0000a051, 0xecdfea0d,
0x10000700, 0x07100df0, 0x00008010, 0xecdfea0d,
0x10000400, 0x04100df0, 0x00008010, 0xecdfea0d,
0x10000300, 0x06100df0, 0x00008010, 0xecdfea0d,
0x10000000, 0x00100df0, 0x00008010, 0xecdfea0d,
0xc8581837, 0x22740275, 0x281eddcc, 0xfa8b9b65
};
static const uint32_t cPixelShaderRegs[] = {
0x00000109,0x00000002,0x14000001,0x00000000,
0x00000001,0x00000100,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x00000000,0x00000000,0x00000000,
0x00000000,0x0000000f,0x00000001,0x00000010,
0x00000000
0x00000109, 0x00000002, 0x14000001, 0x00000000,
0x00000001, 0x00000100, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x0000000f, 0x00000001, 0x00000010,
0x00000000
};
Texture2DShader * Texture2DShader::shaderInstance = NULL;
Texture2DShader *Texture2DShader::shaderInstance = NULL;
Texture2DShader::Texture2DShader()
: vertexShader(cuAttributeCount) {
: vertexShader(cuAttributeCount) {
//! create pixel shader
pixelShader.setProgram(cPixelShaderProgram, sizeof(cPixelShaderProgram), cPixelShaderRegs, sizeof(cPixelShaderRegs));
blurLocation = 0;
colorIntensityLocation = 4;
pixelShader.addUniformVar((GX2UniformVar) {
"unf_blur_texture_direction", GX2_SHADER_VAR_TYPE_FLOAT3, 1, blurLocation, -1
"unf_blur_texture_direction", GX2_SHADER_VAR_TYPE_FLOAT3, 1, blurLocation, -1
});
pixelShader.addUniformVar((GX2UniformVar) {
"unf_color_intensity", GX2_SHADER_VAR_TYPE_FLOAT4, 1, colorIntensityLocation, -1
"unf_color_intensity", GX2_SHADER_VAR_TYPE_FLOAT4, 1, colorIntensityLocation, -1
});
samplerLocation = 0;
pixelShader.addSamplerVar((GX2SamplerVar) {
"sampl_texture", GX2_SAMPLER_VAR_TYPE_SAMPLER_2D, samplerLocation
"sampl_texture", GX2_SAMPLER_VAR_TYPE_SAMPLER_2D, samplerLocation
});
//! create vertex shader
@ -220,22 +220,22 @@ Texture2DShader::Texture2DShader()
offsetLocation = 4;
scaleLocation = 8;
vertexShader.addUniformVar((GX2UniformVar) {
"unf_angle", GX2_SHADER_VAR_TYPE_FLOAT, 1, angleLocation, -1
"unf_angle", GX2_SHADER_VAR_TYPE_FLOAT, 1, angleLocation, -1
});
vertexShader.addUniformVar((GX2UniformVar) {
"unf_offset", GX2_SHADER_VAR_TYPE_FLOAT3, 1, offsetLocation, -1
"unf_offset", GX2_SHADER_VAR_TYPE_FLOAT3, 1, offsetLocation, -1
});
vertexShader.addUniformVar((GX2UniformVar) {
"unf_scale", GX2_SHADER_VAR_TYPE_FLOAT3, 1, scaleLocation, -1
"unf_scale", GX2_SHADER_VAR_TYPE_FLOAT3, 1, scaleLocation, -1
});
positionLocation = 0;
texCoordLocation = 1;
vertexShader.addAttribVar((GX2AttribVar) {
"attr_position", GX2_SHADER_VAR_TYPE_FLOAT3, 0, positionLocation
"attr_position", GX2_SHADER_VAR_TYPE_FLOAT3, 0, positionLocation
});
vertexShader.addAttribVar((GX2AttribVar) {
"attr_texture_coord", GX2_SHADER_VAR_TYPE_FLOAT2, 0, texCoordLocation
"attr_texture_coord", GX2_SHADER_VAR_TYPE_FLOAT2, 0, texCoordLocation
});
//! setup attribute streams
@ -246,8 +246,8 @@ Texture2DShader::Texture2DShader()
fetchShader = new FetchShader(vertexShader.getAttributeBuffer(), vertexShader.getAttributesCount());
//! model vertex has to be align and cannot be in unknown regions for GX2 like 0xBCAE1000
posVtxs = (float*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciPositionVtxsSize);
texCoords = (float*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciTexCoordsVtxsSize);
posVtxs = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciPositionVtxsSize);
texCoords = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciTexCoordsVtxsSize);
//! defaults for normal square
//! position vertex structure and texture coordinate vertex structure
@ -255,14 +255,14 @@ Texture2DShader::Texture2DShader()
posVtxs[i++] = -1.0f;
posVtxs[i++] = -1.0f;
posVtxs[i++] = 0.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = -1.0f;
posVtxs[i++] = 0.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 0.0f;
posVtxs[i++] = -1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 1.0f;
posVtxs[i++] = 0.0f;
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, posVtxs, ciPositionVtxsSize);
@ -279,11 +279,11 @@ Texture2DShader::Texture2DShader()
}
Texture2DShader::~Texture2DShader() {
if(posVtxs) {
if (posVtxs) {
free(posVtxs);
posVtxs = NULL;
}
if(texCoords) {
if (texCoords) {
free(texCoords);
texCoords = NULL;
}