YourWishes/Dawn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First pass UI Alignment

Browse Source
This commit is contained in:
Dominic Masters
2023-12-19 11:43:53 -06:00
parent 11ed44b480
commit fef4adf9c6
11 changed files with 307 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/dawn/component/ui/UICanvas.cpp
View File

@ -60,17 +60,13 @@ struct RenderPassContext &ctx
nextBinding = 0;
// Define the root alignment
struct UIAlign rootAlignment = {
glm::vec2(0, 0),
glm::vec2(1280, 720)
};
// Get the quads for each component
auto itComponents = components.begin();
auto self = std::ref(*this);
while(itComponents != components.end()) {
auto component = *itComponents;
component->getQuads(rootAlignment, self);
component->getQuads(self);
++itComponents;
}
@ -136,4 +132,13 @@ void UICanvas::flushPass() {
nextBinding = 0;
textures.clear();
textureBindings.clear();
}
void UICanvas::addComponent(std::shared_ptr<UIComponent> component) {
components.push_back(component);
component->updateAlignment(
glm::vec2(0, 0),
glm::vec2(1280, 720),
1.0f
);
}

10
src/dawn/component/ui/UICanvas.hpp
View File

@ -18,6 +18,7 @@ namespace Dawn {
private:
std::shared_ptr<Mesh> mesh;
UIShaderData data;
std::vector<std::shared_ptr<UIComponent>> components;
size_t quadCount = 0;
shadertexturebinding_t nextBinding = 0;
@ -41,8 +42,6 @@ namespace Dawn {
void flushPass();
public:
std::vector<std::shared_ptr<UIComponent>> components;
std::vector<std::shared_ptr<IRenderPass>> getPasses(
struct RenderPassContext &ctx
) override;
@ -63,5 +62,12 @@ namespace Dawn {
const enum UIShaderQuadStyle style,
const std::shared_ptr<Texture> texture = nullptr
);
/**
* Adds a component to the canvas.
*
* @param component The component to add.
*/
void addComponent(std::shared_ptr<UIComponent> component);
};
}

2
src/dawn/display/font/TrueTypeTexture.hpp
View File

@ -14,9 +14,9 @@ namespace Dawn {
class TrueTypeTexture final {
private:
FT_Face face;
uint32_t fontSize;
public:
uint32_t fontSize;
std::shared_ptr<Texture> texture;
std::unordered_map<wchar_t, struct TrueTypeCharacter> characterData;

193
src/dawn/ui/UIComponent.cpp
View File

@ -4,29 +4,194 @@
// https://opensource.org/licenses/MIT
#include "UIComponent.hpp"
#include "assert/assert.hpp"
using namespace Dawn;
UIComponent::UIComponent() {
alignUnit[0] = UIAlignmentUnit::SCALE;
alignUnit[1] = UIAlignmentUnit::SCALE;
alignUnit[2] = UIAlignmentUnit::SCALE;
alignUnit[3] = UIAlignmentUnit::SCALE;
eventAlignmentUpdated = [&](const glm::vec2 p, const glm::vec2 s) {
};
}
void UIComponent::updateAlignment(
const glm::vec2 pPos,
const glm::vec2 pSize,
const float_t canvasScale
) {
auto valueAxis = [&](
const enum UIAlignmentUnit unit,
const float_t alignment,
const float_t parentSize,
const float_t ratioSize
) {
switch(unit) {
case UIAlignmentUnit::PIXEL:
return alignment;
case UIAlignmentUnit::SCALE:
return canvasScale * alignment;
case UIAlignmentUnit::PERCENT:
return parentSize * (alignment / 100.0f);
case UIAlignmentUnit::RATIO:
return (alignment / 100.0f) * ratioSize;
default:
assertUnreachable("Invalid UIAlignmentType");
return 0.0f;
}
};
auto alignAxis = [&](
const enum UIAlignmentType type,
const enum UIAlignmentUnit unit0,
const enum UIAlignmentUnit unit1,
const float_t alignment0,
const float_t alignment1,
const float_t parentSize,
const float_t ratioSize,
float_t &selfPosition,
float_t &selfSize
) {
switch(type) {
case UIAlignmentType::START:
selfPosition = valueAxis(
unit0,
alignment0,
parentSize,
ratioSize
);
selfSize = valueAxis(
unit1,
alignment1,
parentSize,
ratioSize
);
break;
case UIAlignmentType::MIDDLE:
selfSize = valueAxis(
unit1,
alignment1,
parentSize,
ratioSize
);
selfPosition = (parentSize / 2.0f) - (selfSize / 2.0f) + valueAxis(
unit0,
alignment0,
parentSize,
ratioSize
);
break;
case UIAlignmentType::END:
selfSize = valueAxis(
unit0,
alignment0,
parentSize,
ratioSize
);
selfPosition = parentSize - selfSize - valueAxis(
unit1,
alignment1,
parentSize,
ratioSize
);
break;
case UIAlignmentType::STRETCH:
selfPosition = valueAxis(
unit0,
alignment0,
parentSize,
ratioSize
);
selfSize = parentSize - (selfPosition + valueAxis(
unit1,
alignment1,
parentSize,
ratioSize
));
break;
default:
assertUnreachable("Invalid UIAlignmentType");
}
};
bool_t heightFirst = (
alignUnit[0] == UIAlignmentUnit::RATIO ||
alignUnit[2] == UIAlignmentUnit::RATIO
);
if(heightFirst) {
// Align height first, this will define size.y which we can use as the ratio
// for the width/X axis alignment.
alignAxis(
alignY,
alignUnit[1],
alignUnit[3],
align[1],
align[3],
pSize.y,
0,
position.y,
size.y
);
alignAxis(
alignX,
alignUnit[0],
alignUnit[2],
align[0],
align[2],
pSize.x,
size.y,
position.x,
size.x
);
} else {
alignAxis(
alignX,
alignUnit[0],
alignUnit[2],
align[0],
align[2],
pSize.x,
0,
position.x,
size.x
);
alignAxis(
alignY,
alignUnit[1],
alignUnit[3],
align[1],
align[3],
pSize.y,
size.x,
position.y,
size.y
);
}
this->eventAlignmentUpdated(position, size);
}
std::vector<std::shared_ptr<UIComponent>> UIComponent::getChildren() {
return {};
}
void UIComponent::getQuads(
const struct UIAlign alignment,
UICanvas &ctx
) {
auto selfAlignment = getSelfAlignment(alignment);
this->getSelfQuads(selfAlignment, ctx);
void UIComponent::getQuads(UICanvas &ctx) {
this->getSelfQuads(ctx);
auto children = getChildren();
for(auto &c : children) {
c->getQuads(selfAlignment, ctx);
c->getQuads(ctx);
}
}
struct UIAlign UIComponent::getSelfAlignment(const struct UIAlign alignment) {
return (struct UIAlign){
alignment.position + position,
alignment.size
};
}

57
src/dawn/ui/UIComponent.hpp
View File

@ -8,13 +8,25 @@
#include "component/ui/UICanvas.hpp"
namespace Dawn {
struct UIAlign {
glm::vec2 position;
glm::vec2 size;
enum class UIAlignmentType {
START,
MIDDLE,
END,
STRETCH
};
enum class UIAlignmentUnit {
PIXEL,
SCALE,
PERCENT,
RATIO
};
class UIComponent {
protected:
glm::vec2 position;
glm::vec2 size;
/**
* Virtual method overridden by the UIComponent to get the quads for the
* component.
@ -22,21 +34,34 @@ namespace Dawn {
* @param alignment The alignment of this component.
* @param ctx The canvas to add the quads to.
*/
virtual void getSelfQuads(
const struct UIAlign alignment,
UICanvas &ctx
) = 0;
virtual void getSelfQuads(UICanvas &ctx) = 0;
/**
* Allows a component to modify its self alignment.
* Updates the alignment of this component based on the parent.
*
* @param alignment Aliugnment to modify.
* @return New alignment for this component.
* @param parentPosition The position of the parent.
* @param parentSize The size of the parent.
*/
virtual struct UIAlign getSelfAlignment(const struct UIAlign alignment);
void updateAlignment(
const glm::vec2 parentPosition,
const glm::vec2 parentSize,
const float_t canvasScale
);
public:
glm::vec2 position;
glm::vec4 align = glm::vec4(0, 0, 32, 32);
enum UIAlignmentType alignX = UIAlignmentType::START;
enum UIAlignmentType alignY = UIAlignmentType::START;
enum UIAlignmentUnit alignUnit[4];
std::function<
void(const glm::vec2, const glm::vec2)
> eventAlignmentUpdated;
/**
* Instantiates a new UIComponent.
*/
UIComponent();
/**
* Virtual method overridden by the UIComponent to get the children of
@ -47,12 +72,10 @@ namespace Dawn {
/**
* Method called by the UICanvas to get the quads for this component.
*
* @param alignment The alignment of this component.
* @param ctx The canvas to add the quads to.
*/
void getQuads(
const struct UIAlign alignment,
UICanvas &ctx
);
void getQuads(UICanvas &ctx);
friend class UICanvas;
};
}

63
src/dawn/ui/UILabel.cpp
View File

@ -7,24 +7,67 @@
using namespace Dawn;
void UILabel::getSelfQuads(
const struct UIAlign alignment,
UICanvas &ctx
) {
void UILabel::getSelfQuads(UICanvas &ctx) {
std::vector<struct UIShaderQuad> quads;
if(this->texture == nullptr || this->text.empty()) return;
glm::vec4 quad;
glm::vec2 pos = alignment.position;
glm::vec2 pos = glm::vec2(0, this->texture->fontSize);
bool_t lastCharWasSpace = false;
for(wchar_t c : text) {
for(size_t i = 0; i < text.size(); i++) {
wchar_t c = text[i];
auto info = texture->getCharacterData(c);
// Newline(s)
if(c == L'\n') {
pos.x = 0;
pos.y += this->texture->fontSize;
continue;
}
// Spaces
if(c == L' ') {
pos.x += info.advance.x;
lastCharWasSpace = true;
continue;
}
// Word Wrap
if(wordWrap) {
if(lastCharWasSpace) {
// Scan ahead to next space
float_t wordWidth = pos.x;// Start at current position and scan ahead.
for(size_t j = i; j < text.size(); j++) {
wchar_t c2 = text[j];
if(c2 == L' ' || c2 == L'\n') {
break;// If we hit another space, we are OK.
}
// Will this character fit on the row? If not the whole word will wrap.
auto info2 = texture->getCharacterData(c);
wordWidth += info.advance.x;
if(wordWidth > size.x) {
pos.x = 0;
pos.y += this->texture->fontSize;
break;
}
}
lastCharWasSpace = false;
}
} else if(pos.x + info.size.x > position.x + size.x) {
// Not word wrap, but instead just overflow characters.
pos.x = 0;
pos.y += this->texture->fontSize;
}
ctx.addQuad(
{
pos.x + info.offset.x,
pos.y + info.offset.y,
pos.x + info.size.x + info.offset.x,
pos.y + info.size.y + info.offset.y
position.x + pos.x + info.offset.x,
position.y + pos.y + info.offset.y,
position.x + pos.x + info.size.x + info.offset.x,
position.y + pos.y + info.size.y + info.offset.y
},
{
info.quad.x,

7
src/dawn/ui/UILabel.hpp
View File

@ -14,12 +14,11 @@ namespace Dawn {
std::wstring text = L"Hello World";
protected:
void getSelfQuads(
const struct UIAlign alignment,
UICanvas &ctx
) override;
void getSelfQuads(UICanvas &ctx) override;
public:
bool_t wordWrap = true;
/**
* Returns the font used for this label.
*

7
src/dawn/ui/UIRectangle.cpp
View File

@ -7,13 +7,10 @@
using namespace Dawn;
void UIRectangle::getSelfQuads(
const struct UIAlign alignment,
UICanvas &ctx
) {
void UIRectangle::getSelfQuads(UICanvas &ctx) {
std::vector<struct UIShaderQuad> quads;
ctx.addQuad(
glm::vec4(alignment.position, alignment.position + size),
glm::vec4(position, position + size),
uv,
color,
UIShaderQuadStyle::TEXTURED,

6
src/dawn/ui/UIRectangle.hpp
View File

@ -9,15 +9,11 @@
namespace Dawn {
class UIRectangle final : public UIComponent {
protected:
void getSelfQuads(
const struct UIAlign alignment,
UICanvas &ctx
) override;
void getSelfQuads(UICanvas &ctx) override;
public:
struct Color color = COLOR_WHITE;
std::shared_ptr<Texture> texture = nullptr;
glm::vec2 size = glm::vec2(32, 32);
glm::vec4 uv = glm::vec4(0,0,1,1);
};
}

2
src/dawnglfw/display/RenderHost.cpp
View File

@ -98,7 +98,7 @@ void RenderHost::update(const std::shared_ptr<Game> game) {
assertNoGLError();
glDepthFunc(GL_LESS);
assertNoGLError();
glEnable(GL_DEPTH_TEST);
// glEnable(GL_DEPTH_TEST);
assertNoGLError();
glEnable(GL_BLEND);
assertNoGLError();

15
src/dawnhelloworld/scene/HelloWorldScene.cpp
View File

@ -56,14 +56,17 @@ void Dawn::helloWorldScene(Scene &s) {
auto uiCanvas = uiCanvasItem->addComponent<UICanvas>();
auto rect = std::make_shared<UIRectangle>();
rect->position = { 32, 32 };
rect->size = { texture->texture->getWidth(), texture->texture->getHeight() };
rect->color = COLOR_MAGENTA;
rect->texture = texture->texture;
uiCanvas->components.push_back(rect);
rect->align = { 32, 32, 300, 250 };
rect->alignX = UIAlignmentType::START;
rect->alignY = UIAlignmentType::START;
uiCanvas->addComponent(rect);
auto label = std::make_shared<UILabel>();
label->setText(L"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.");
label->setFont(texture);
label->position = { 32, 650 };
uiCanvas->components.push_back(label);
label->align = { 32, 32, 300, 250 };
label->alignX = UIAlignmentType::START;
label->alignY = UIAlignmentType::START;
uiCanvas->addComponent(label);
}