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

New XML System, first pass.

Browse Source
This commit is contained in:
Dominic Masters
2023-07-12 10:34:51 -07:00
parent 1c7abbf140
commit 19c6575aaf
9 changed files with 126 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/SDL

Submodule lib/SDL updated: c065a9b128...4a53dc5b8d

2
lib/freetype

Submodule lib/freetype updated: e4586d960f...dec2743e6a

2
lib/openal-soft

Submodule lib/openal-soft updated: 2da9d168b6...05f9ce8b97

1
src/dawn/scene/components/ui/text/UILabel.cpp
View File

@ -122,6 +122,7 @@ void UILabel::rebufferQuads(const std::vector<struct UILabelText> newTexts) {
// Reset
lines.clear();
textureMap.clear();
// Determine font dimensions.
auto itText = newTexts.begin();

46
src/dawn/scene/components/ui/text/UIRichTextLabel.cpp
View File

@ -29,33 +29,33 @@ void UIRichTextLabel::onStart() {
}
std::function<void(Xml*)> parseChildren = [&](Xml *node) {
if(node->children.empty()) {
if(node->node == "root") return;
struct UILabelText text;
text.style = current;
text.text = node->value;
bufferTexts.push_back(text);
} else {
auto itNode = node->children.begin();
while(itNode != node->children.end()) {
auto child = *itNode;
assertTrue(child->node == "font");
auto itChildren = node->childNodes.begin();
while(itChildren != node->childNodes.end()) {
auto child = *itChildren;
if(child.nodeType == XML_NODE_TYPE_TEXT) {
struct UILabelText text;
text.style = current;
text.text = child.value;
bufferTexts.push_back(text);
} else if(child.nodeType == XML_NODE_TYPE_ELEMENT) {
auto node = child.child;
assertTrue(node->node == "font");
struct UILabelStyle style;
if(child->attributes.contains("font")) {
style.font = this->getGame()->assetManager.get<TrueTypeAsset>(child->attributes["font"]);
if(node->attributes.contains("font")) {
style.font = this->getGame()->assetManager.get<TrueTypeAsset>(node->attributes["font"]);
} else {
style.font = current.font;
}
if(child->attributes.contains("size")) {
style.size = std::stoi(child->attributes["size"]);
if(node->attributes.contains("size")) {
style.size = std::stoi(node->attributes["size"]);
} else {
style.size = current.size;
}
if(child->attributes.contains("style")) {
std::string s = child->attributes["style"];
if(node->attributes.contains("style")) {
std::string s = node->attributes["style"];
style.style = 0;
if(s.find("bold") != std::string::npos) style.style |= TRUE_TYPE_VARIANT_BOLD;
if(s.find("italic") != std::string::npos) style.style |= TRUE_TYPE_VARIANT_ITALICS;
@ -63,25 +63,23 @@ void UIRichTextLabel::onStart() {
style.style = current.style;
}
if(child->attributes.contains("color")) {
style.color = Color::fromString(child->attributes["color"]);
if(node->attributes.contains("color")) {
style.color = Color::fromString(node->attributes["color"]);
} else {
style.color = current.color;
}
styleStack.push_back(style);
current = style;
parseChildren(child);
parseChildren(node);
styleStack.pop_back();
current = styleStack.back();
++itNode;
}
++itChildren;
}
};
auto root = Xml::load("<root>" + ((std::string)this->richText) + "</root>");
auto root = Xml::load("<root><font font=\"font_main\">" + ((std::string)this->richText) + "</font></root>");
parseChildren(&root);
this->rebufferQuads(bufferTexts);
}, this->richText)();

17
src/dawnliminal/scenes/HelloWorldScene.hpp
View File

@ -8,7 +8,6 @@
#include "prefabs/SimpleSpinningCubePrefab.hpp"
#include "scene/components/display/Camera.hpp"
#include "scene/components/ui/text/UIRichTextLabel.hpp"
#include "prefabs/VNTextbox.hpp"
namespace Dawn {
class HelloWorldScene : public Scene {
@ -25,28 +24,12 @@ namespace Dawn {
auto canvasItem = this->createSceneItem();
auto canvas = canvasItem->addComponent<UICanvas>();
canvas->camera = camera;
auto textboxItem = this->createSceneItem();
auto textbox = textboxItem->addComponent<UIRichTextLabel>();
textbox->alignX = UI_COMPONENT_ALIGN_STRETCH;
textbox->alignY = UI_COMPONENT_ALIGN_STRETCH;
textbox->alignment = glm::vec4(0, 0, 0, 0);
textbox->richText = std::string(
"<font font=\"font_main\" size=\"64\" style=\"italics\" color=\"MAGENTA\">"
"Hello World"
"</font>"
"<font font=\"font_main\" size=\"64\" style=\"bold\" color=\"WHITE\">"
"BBBBBB"
"</font>"
);
textbox->transform->setParent(canvas->transform);
}
std::vector<Asset*> getRequiredAssets() override {
auto assMan = &this->game->assetManager;
std::vector<Asset*> assets;
vectorAppend(&assets, SimpleSpinningCubePrefab::getRequiredAssets(assMan));
assets.push_back(assMan->get<TrueTypeAsset>("font_main"));
return assets;
}

188
src/dawnshared/util/Xml.cpp
View File

@ -7,6 +7,12 @@
using namespace Dawn;
XmlNode::XmlNode() {
this->child = nullptr;
this->value.clear();
}
bool_t Xml::isWhitespace(char_t c) {
return c == ' ' || c == '\r' || c == '\n' || c == '\t';
}
@ -26,9 +32,8 @@ void Xml::load(Xml *xml, std::string data, size_t *j) {
bool_t insideTag = false;
std::string buffer = "";
std::string attrKey = "";
std::string bufferWhitespaces;
bool_t valueIsInWhitespace = false;
size_t i = *j;
struct XmlNode childNode;
while(c = data[i++]) {
if(insideTag) {
@ -39,26 +44,21 @@ void Xml::load(Xml *xml, std::string data, size_t *j) {
case XML_PARSE_STATE_DOING_NOTHING:
if(c == '>') continue;
if(c == '<') {
// Parsing comment?
if(data[i] == '!' && data[i+1] == '-' && data[i+2] == '-') {
doingBeforeComment = doing;
doing = XML_PARSE_STATE_PARSING_COMMENT;
i += 3;
} else if(data[i] == '!' && !insideTag) {
// Likely <!DOCTYPE ...>
while((c = data[i++]) != '>') {
// Nothing needs doing here right now, in future may support doctype
}
continue;
} else if(insideTag) {
if(data[i] == '/') {
i -= 1;
doing = XML_PARSE_STATE_PARSING_CHILD;
} else {
i -= 1;
auto child = new Xml();
Xml::load(child, data, &i);
xml->children.push_back(child);
doing = XML_PARSE_STATE_PARSING_CHILD;
// Remove last char since we kinda already parsed it.
xml->innerXml += child->outerXml;
xml->outerXml = xml->outerXml.substr(0, xml->outerXml.size()-1);
xml->outerXml += child->outerXml;
doing = XML_PARSE_STATE_PARSING_CLOSE;
continue;
}
} else {
doing = XML_PARSE_STATE_PARSING_TAG_NAME;
@ -69,8 +69,8 @@ void Xml::load(Xml *xml, std::string data, size_t *j) {
continue;
}
xml->innerXml += c;
if(Xml::isWhitespace(c)) continue;
if(insideTag) xml->innerXml += c;
if(Xml::isWhitespace(c)) continue;// NEEDS TO GO?
doing = XML_PARSE_STATE_PARSING_VALUE;
buffer += c;
break;
@ -86,7 +86,7 @@ void Xml::load(Xml *xml, std::string data, size_t *j) {
insideTag = false;
doing = XML_PARSE_STATE_PARSING_CLOSE;
} else {
doing = c == '>' ? XML_PARSE_STATE_DOING_NOTHING : XML_PARSE_STATE_LOOKING_FOR_ATTRIBUTE;
doing = c == '>' ? XML_PARSE_STATE_PARSING_VALUE : XML_PARSE_STATE_LOOKING_FOR_ATTRIBUTE;
}
continue;
}
@ -98,7 +98,7 @@ void Xml::load(Xml *xml, std::string data, size_t *j) {
// Look until we hit either the end of a tag, or the attribute itself
if(Xml::isWhitespace(c) || c == '>' || c == '/' || c == '=') {
if(c == '>' || c == '/') {
doing = XML_PARSE_STATE_DOING_NOTHING;
doing = XML_PARSE_STATE_PARSING_VALUE;
if(c == '/') {
level--;
insideTag = false;
@ -149,116 +149,86 @@ void Xml::load(Xml *xml, std::string data, size_t *j) {
case XML_PARSE_STATE_PARSING_VALUE:
// Keep parsing child until we find a < for an opening/closing tag.
if(c == '<' && !(data[i] == '<' || data[i-2] == '<')) {
if(buffer.size() > 0) {
childNode.nodeType = XML_NODE_TYPE_TEXT;
childNode.value = buffer;
xml->childNodes.push_back(childNode);
}
// Are we parsing the close tag, or parsing a child?
if(data[i] == '/') {
// In HTML Spec there could be a child here but not in XML spec.
doing = XML_PARSE_STATE_PARSING_CLOSE;
xml->value = buffer;
xml->textContent = buffer;
buffer.clear();
valueIsInWhitespace = false;
bufferWhitespaces.clear();
continue;
}
std::cout << "Detected unsupported use of a child within a node value, e.g. <div>Hello <b>world</b> how are you?</div>" << std::endl;
throw "Test";
continue;
}
xml->innerXml += c;
if(Xml::isWhitespace(c)) {
if(!valueIsInWhitespace) {
bufferWhitespaces.clear();
bufferWhitespaces += c;
valueIsInWhitespace = true;
} else {
if(c != ' ') bufferWhitespaces += c;
}
// TODO: I can maybe consider indentation here
} else {
if(valueIsInWhitespace) {
buffer += bufferWhitespaces;
valueIsInWhitespace = false;
}
if(c == '&') {
// Handle special characters. First read ahead to nearest semicolon OR
// nearest closing tag.
std::string sc;
while(c = data[i++]) {
xml->innerXml += c;
if(c == ';') break;
if(c == '<') assertUnreachable();//Invalid XML
sc += c;
}
if(valueIsInWhitespace) {
buffer += bufferWhitespaces;
valueIsInWhitespace = false;
}
if(sc == "lt") {
buffer += '<';
} else if(sc == "gt") {
buffer += '>';
} else if(sc == "amp") {
buffer += '&';
} else if(sc == "apos") {
buffer += '\'';
} else if(sc == "quot") {
buffer += '"';
} else if(sc == "nbsp") {
buffer += ' ';
} else {
// Try parse as integer
if(sc.size() > 1 && sc[0] == '#') {
int code = std::stoi(sc.substr(1));
buffer += (char)code;
} else {
std::cout << "Unknown Special character: " << sc << std::endl;
assertUnreachable();
}
}
} else {
buffer += c;
}
}
break;
case XML_PARSE_STATE_PARSING_CHILD:
if(c == '<') {
// Read ahead and confirm this is a close or not
if(data[i] == '/') {
doing = XML_PARSE_STATE_PARSING_CLOSE;
continue;
}
if(data[i] == '!' && data[i+1] == '-' && data[i+2] == '-') {
} else if(data[i] == '!' && data[i+1] == '-' && data[i+2] == '-') {
doingBeforeComment = doing;
doing = XML_PARSE_STATE_PARSING_COMMENT;
i += 3;
continue;
}
// Likely another child.
auto child = new Xml();
// Parsing child
i -= 1;
// @deprecated
auto child = new Xml();
Xml::load(child, data, &i);
xml->children.push_back(child);
childNode = XmlNode();
childNode.nodeType = XML_NODE_TYPE_ELEMENT;
childNode.child = child;
xml->childNodes.push_back(childNode);
// Remove last char since we kinda already parsed it.
xml->innerXml += child->outerXml;
xml->outerXml = xml->outerXml.substr(0, xml->outerXml.size()-1);
xml->outerXml += child->outerXml;
}
if(Xml::isWhitespace(c)) {
xml->innerXml += c;
buffer.clear();
continue;
}
// In HTML Spec there's a chance for there to be a value here, but not
// in the XML spec.
xml->innerXml += c;
if(c == '&') {
// Handle special characters. First read ahead to nearest semicolon OR
// nearest closing tag.
std::string sc;
while(c = data[i++]) {
xml->innerXml += c;
if(c == ';') break;
if(c == '<') assertUnreachable();//Invalid XML
sc += c;
}
if(sc == "lt") {
buffer += '<';
} else if(sc == "gt") {
buffer += '>';
} else if(sc == "amp") {
buffer += '&';
} else if(sc == "apos") {
buffer += '\'';
} else if(sc == "quot") {
buffer += '"';
} else if(sc == "nbsp") {
buffer += ' ';
} else {
// Try parse as integer
if(sc.size() > 1 && sc[0] == '#') {
int code = std::stoi(sc.substr(1));
buffer += (char)code;
} else {
std::cout << "Unknown Special character: " << sc << std::endl;
assertUnreachable();
}
}
} else {
buffer += c;
}
break;
case XML_PARSE_STATE_PARSING_CLOSE:

22
src/dawnshared/util/Xml.hpp
View File

@ -17,11 +17,18 @@ namespace Dawn {
XML_PARSE_STATE_LOOKING_FOR_ATTRIBUTE_VALUE,
XML_PARSE_STATE_PARSING_ATTRIBUTE_VALUE,
XML_PARSE_STATE_PARSING_VALUE,
XML_PARSE_STATE_PARSING_CHILD,
XML_PARSE_STATE_PARSING_CLOSE,
XML_PARSE_STATE_PARSING_COMMENT
};
class Xml;
struct XmlNode;
enum XmlNodeType {
XML_NODE_TYPE_TEXT,
XML_NODE_TYPE_ELEMENT
};
class Xml {
protected:
static bool_t isWhitespace(char_t c);
@ -31,10 +38,13 @@ namespace Dawn {
static void load(Xml *xml, std::string data, size_t *j);
std::string node;
std::string value;
std::string innerXml;
std::string outerXml;
std::string textContent;
std::map<std::string, std::string> attributes;
std::vector<struct XmlNode> childNodes;
// @deprecated
std::vector<Xml*> children;
std::vector<Xml*> getChildrenOfType(std::string type);
@ -42,4 +52,12 @@ namespace Dawn {
~Xml();
};
struct XmlNode {
enum XmlNodeType nodeType;
std::string value;
Xml *child;
XmlNode();
};
}

2
src/dawntools/util/parser/SceneCodeParser.cpp
View File

@ -33,7 +33,7 @@ int32_t SceneCodeParser::onParse(
}
// Get the code
out->code = node->value;
out->code = node->textContent;
return 0;
}