Anthony/open-story-teller
1
0
Fork 0
mirror of https://github.com/arabine/open-story-teller.git synced 2025-12-06 17:09:06 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

usage of submodules instead of git fetch

Browse source 
multiple fixes/file moves
This commit is contained in:
anthony@rabine.fr 2025-01-28 22:31:05 +01:00
parent 59114c2a80
commit 157c5a5a01
102 changed files with 42782 additions and 2914 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
.gitmodules vendored Normal file
View file

@ -0,0 +1,15 @@
[submodule "story-editor/externals/SDL_mixer"]
path = story-editor/externals/SDL_mixer
url = https://github.com/libsdl-org/SDL_mixer
[submodule "story-editor/externals/SDL"]
path = story-editor/externals/SDL
url = https://github.com/libsdl-org/SDL
[submodule "story-editor/externals/SDL_image"]
path = story-editor/externals/SDL_image
url = https://github.com/libsdl-org/SDL_image
[submodule "story-editor/externals/civetweb"]
path = story-editor/externals/civetweb
url = https://github.com/civetweb/civetweb
[submodule "story-editor/externals/curl"]
path = story-editor/externals/curl
url = https://github.com/curl/curl

10
.vscode/c_cpp_properties.json vendored Normal file
View file

@ -0,0 +1,10 @@
{
"configurations": [
{
"name": "Linux",
"includePath": ["${workspaceFolder}/**", "~/.conan2/**"]
}
],
"version": 4,
"enableConfigurationSquiggles": true
}

2
core/chip32/chip32_assembler.cpp
View file

@ -459,7 +459,7 @@ bool Assembler::Parse(const std::string &data)
else // RAM DATA, only one argument is used: the size of the array
{
instr.addr = ram_addr;
instr.dataLen = static_cast<uint16_t>(strtol(lineParts[2].c_str(), NULL, 0));
instr.dataLen = static_cast<uint16_t>(strtol(lineParts[2].c_str(), NULL, 0)) * instr.dataTypeSize/8;
ram_addr += instr.dataLen;
m_labels[opcode] = instr;
m_instructions.push_back(instr);

7
core/story-manager/interfaces/i_story_manager.h
View file

@ -10,6 +10,7 @@
#include "resource.h"
#include "connection.h"
#include "base_node.h"
#include "variable.h"
template <typename T>
struct Callback;
@ -49,9 +50,15 @@ public:
// Node interaction
virtual void BuildNodes(bool compileonly) = 0;
virtual void BuildCode(bool compileonly) = 0;
virtual void SetExternalSourceFile(const std::string &filename) = 0;
virtual void LoadBinaryStory(const std::string &filename) = 0;
virtual void ToggleBreakpoint(int line) = 0;
virtual uint32_t GetRegister(int reg) = 0;
// Variables management
virtual void ScanVariable(const std::function<void(Variable& element)>& operation) = 0;
virtual void AddVariable() = 0;
virtual void DeleteVariable(int i) = 0;
virtual void Play() = 0;
virtual void Step() = 0;

20
core/story-manager/lib/variable.h Normal file
View file

@ -0,0 +1,20 @@
#pragma once
#include <string>
#include <cstdint>
struct Variable {
static const uint32_t NameMaxSize = 50;
std::string name; // Nom de la variable
std::string type; // Type de la variable (par exemple int32_t, int64_t)
int64_t value; // Valeur stockée en tant qu'entier en virgule fixe
std::string valueText;
int scalePower; // Nombre de bits pour la partie fractionnaire
Variable(const std::string &n, const std::string &t, int64_t v, int s) {
name = n;
type = t;
value = v;
scalePower = s;
}
};

53
core/story-manager/src/branch_node.cpp Normal file
View file

@ -0,0 +1,53 @@
#include "branch_node.h"
#include "story_project.h"
#include "connection.h"
#include "sys_lib.h"
#include "compiler.h"
BranchNode::BranchNode(const std::string &type)
: BaseNode(type, "Branch Node")
{
}
void BranchNode::Initialize()
{
}
std::string BranchNode::GenerateConstants(IStoryPage &page, IStoryProject &project, int nb_out_conns)
{
std::string s;
return s;
}
std::string BranchNode::Build(IStoryPage &page, const StoryOptions &options, int nb_out_conns)
{
std::stringstream ss;
std::list<std::shared_ptr<Connection>> conns;
page.GetNodeConnections(conns, GetId());
int i = 0;
std::list<std::shared_ptr<Connection>>::iterator c = conns.begin();
if (conns.size() == 2)
{
ss << R"(; ---------------------------- )"
<< GetTitle()
<< " Type: Branch"
<< "\n";
ss << "eq r0, r0, r1\n"
<< "skipz r0\n"
<< "jump " << BaseNode::GetEntryLabel((*c)->inNodeId);
++c;
ss << "jump " << BaseNode::GetEntryLabel((*c)->inNodeId);
}
return ss.str();
}

21
core/story-manager/src/branch_node.h Normal file
View file

@ -0,0 +1,21 @@
#pragma once
#include <string>
#include "i_story_manager.h"
#include "base_node.h"
#include "i_script_node.h"
#include "i_story_project.h"
class BranchNode : public BaseNode
{
public:
BranchNode(const std::string &type);
virtual void Initialize() override;
virtual std::string Build(IStoryPage &page, const StoryOptions &options, int nb_out_conns) override;
virtual std::string GenerateConstants(IStoryPage &page, IStoryProject &project, int nb_out_conns) override;
private:
};

79
core/story-manager/src/compare_node.cpp Normal file
View file

@ -0,0 +1,79 @@
#include "compare_node.h"
#include "story_project.h"
#include "connection.h"
#include "sys_lib.h"
#include "compiler.h"
CompareNode::CompareNode(const std::string &type)
: BaseNode(type, "Branch Node")
{
}
void CompareNode::Initialize()
{
}
std::string CompareNode::GenerateConstants(IStoryPage &page, IStoryProject &project, int nb_out_conns)
{
std::string s;
return s;
}
std::string CompareNode::Build(IStoryPage &page, const StoryOptions &options, int nb_out_conns)
{
std::stringstream ss;
std::list<std::shared_ptr<Connection>> conns;
page.GetNodeConnections(conns, GetId());
int i = 0;
std::list<std::shared_ptr<Connection>>::iterator c = conns.begin();
/*
; Déclaration des variables en RAM
$var1 DV32 1 ; Première variable à comparer
$var2 DV32 1 ; Deuxième variable à comparer
; Code principal
.compare_ge:
; Charger les valeurs des variables dans les registres
lcons r1, $var1
load r1, @r1, 4 ; Charger 4 bytes (32 bits) de var1 dans r1
lcons r2, $var2
load r2, @r2, 4 ; Charger 4 bytes (32 bits) de var2 dans r2
; Comparer r1 >= r2
gt r3, r1, r2 ; r3 = 1 si r1 > r2, sinon 0
eq r4, r1, r2 ; r4 = 1 si r1 == r2, sinon 0
or r0, r3, r4 ; r0 = 1 si r1 > r2 OU r1 == r2, sinon 0
ret
*/
if (conns.size() == 2)
{
ss << R"(; ---------------------------- )"
<< GetTitle()
<< " Type: Branch"
<< "\n";
ss << "eq r0, r0, r1\n"
<< "skipz r0\n"
<< "jump " << BaseNode::GetEntryLabel((*c)->inNodeId);
++c;
ss << "jump " << BaseNode::GetEntryLabel((*c)->inNodeId);
}
return ss.str();
}

21
core/story-manager/src/compare_node.h Normal file
View file

@ -0,0 +1,21 @@
#pragma once
#include <string>
#include "i_story_manager.h"
#include "base_node.h"
#include "i_script_node.h"
#include "i_story_project.h"
class CompareNode : public BaseNode
{
public:
CompareNode(const std::string &type);
virtual void Initialize() override;
virtual std::string Build(IStoryPage &page, const StoryOptions &options, int nb_out_conns) override;
virtual std::string GenerateConstants(IStoryPage &page, IStoryProject &project, int nb_out_conns) override;
private:
};

20
core/story-manager/src/story_project.cpp
View file

@ -9,6 +9,7 @@
#include "json.hpp"
#include "media_node.h"
#include "function_node.h"
#include "variable_node.h"
#include "sys_lib.h"
StoryProject::StoryProject(ILogger &log)
@ -16,6 +17,7 @@ StoryProject::StoryProject(ILogger &log)
{
registerNode<MediaNode>("media-node");
registerNode<FunctionNode>("function-node");
registerNode<VariableNode>("variable-node");
}
StoryProject::~StoryProject()
@ -221,6 +223,24 @@ std::pair<std::list<std::shared_ptr<Connection>>::iterator, std::list<std::share
return std::pair<std::list<std::shared_ptr<Connection>>::iterator, std::list<std::shared_ptr<Connection>>::iterator>();
}
void StoryProject::ScanVariable(const std::function<void(Variable& element)>& operation)
{
for (auto &v : m_variables)
{
operation(v);
}
}
void StoryProject::AddVariable()
{
m_variables.push_back(Variable("var_" + std::to_string(m_variables.size()), "int32_t", 0, 8));
}
void StoryProject::DeleteVariable(int i)
{
m_variables.erase(m_variables.begin() + i);
}
bool StoryProject::ModelFromJson(const nlohmann::json &model)
{
bool success = false;

9
core/story-manager/src/story_project.h
View file

@ -15,7 +15,7 @@
#include "chip32_assembler.h"
#include "story_page.h"
#include "story_options.h"
#include "variable.h"
struct StoryProject : public IStoryProject
{
@ -102,6 +102,11 @@ public:
std::pair<std::list<std::shared_ptr<BaseNode>>::iterator, std::list<std::shared_ptr<BaseNode>>::iterator> Nodes(const std::string_view &page_uuid);
std::pair<std::list<std::shared_ptr<Connection>>::iterator, std::list<std::shared_ptr<Connection>>::iterator> Links(const std::string_view &page_uuid);
void ScanVariable(const std::function<void(Variable& element)>& operation);
void AddVariable();
void DeleteVariable(int i);
std::vector<std::string> GetNodeTypes() const {
std::vector<std::string> l;
for(auto const& imap: m_registry) l.push_back(imap.first);
@ -129,6 +134,8 @@ private:
std::list<std::shared_ptr<StoryPage>> m_pages;
std::vector<Variable> m_variables;
StoryOptions m_storyOptions;
bool m_initialized{false};

43
core/story-manager/src/variable_node.cpp Normal file
View file

@ -0,0 +1,43 @@
#include "variable_node.h"
#include "story_project.h"
#include "connection.h"
#include "sys_lib.h"
VariableNode::VariableNode(const std::string &type)
: BaseNode(type, "Function Node")
{
nlohmann::json j{ {"function", ""} };
SetInternalData(j);
}
void VariableNode::StoreInternalData()
{
nlohmann::json j;
// j["image"] = m_image;
// j["sound"] = m_sound;
SetInternalData(j);
}
void VariableNode::Initialize()
{
nlohmann::json j = GetInternalData();
// m_image = j["image"].get<std::string>();
// m_sound = j["sound"].get<std::string>();
}
std::string VariableNode::Build(IStoryPage &page, const StoryOptions &options, int nb_out_conns)
{
return std::string();
}
std::string VariableNode::GenerateConstants(IStoryPage &page, IStoryProject &project, int nb_out_conns)
{
std::string s;
return s;
}

23
core/story-manager/src/variable_node.h Normal file
View file

@ -0,0 +1,23 @@
#pragma once
#include <string>
#include "i_story_manager.h"
#include "base_node.h"
#include "i_script_node.h"
#include "i_story_project.h"
class VariableNode : public BaseNode
{
public:
VariableNode(const std::string &type);
virtual void Initialize() override;
virtual std::string Build(IStoryPage &page, const StoryOptions &options, int nb_out_conns) override;
virtual std::string GenerateConstants(IStoryPage &page, IStoryProject &project, int nb_out_conns) override;
void StoreInternalData();
private:
};

3
firmware/library/mini_qoi.c
View file

@ -21,6 +21,7 @@ Initializes an mQOI image descriptor object.
void mqoi_desc_init(mqoi_desc_t *desc)
{
memset(desc, 0, sizeof(mqoi_desc_t));
desc->head = 3;
}
/*
@ -74,7 +75,7 @@ Returns true when the mQOI image descriptor object is completely populated.
*/
inline bool mqoi_desc_done(const mqoi_desc_t *desc)
{
return desc->head >= sizeof(mqoi_desc_t) - 1;
return desc->head >= sizeof(mqoi_desc_t) - 4;
}
// ==== mqoi_dec_t ====

2
firmware/library/mini_qoi.h
View file

@ -75,7 +75,7 @@ extern "C"
typedef struct
{
uint8_t head;
uint32_t head; // fix: allow alignment of 32-bit addresses
uint8_t magic[4];
uint8_t width[4]; // big-endian width

649
firmware/library/qoi.h
View file

@ -1,649 +0,0 @@
/*
Copyright (c) 2021, Dominic Szablewski - https://phoboslab.org
SPDX-License-Identifier: MIT
QOI - The "Quite OK Image" format for fast, lossless image compression
-- About
QOI encodes and decodes images in a lossless format. Compared to stb_image and
stb_image_write QOI offers 20x-50x faster encoding, 3x-4x faster decoding and
20% better compression.
-- Synopsis
// Define `QOI_IMPLEMENTATION` in *one* C/C++ file before including this
// library to create the implementation.
#define QOI_IMPLEMENTATION
#include "qoi.h"
// Encode and store an RGBA buffer to the file system. The qoi_desc describes
// the input pixel data.
qoi_write("image_new.qoi", rgba_pixels, &(qoi_desc){
.width = 1920,
.height = 1080,
.channels = 4,
.colorspace = QOI_SRGB
});
// Load and decode a QOI image from the file system into a 32bbp RGBA buffer.
// The qoi_desc struct will be filled with the width, height, number of channels
// and colorspace read from the file header.
qoi_desc desc;
void *rgba_pixels = qoi_read("image.qoi", &desc, 4);
-- Documentation
This library provides the following functions;
- qoi_read -- read and decode a QOI file
- qoi_decode -- decode the raw bytes of a QOI image from memory
- qoi_write -- encode and write a QOI file
- qoi_encode -- encode an rgba buffer into a QOI image in memory
See the function declaration below for the signature and more information.
If you don't want/need the qoi_read and qoi_write functions, you can define
QOI_NO_STDIO before including this library.
This library uses malloc() and free(). To supply your own malloc implementation
you can define QOI_MALLOC and QOI_FREE before including this library.
This library uses memset() to zero-initialize the index. To supply your own
implementation you can define QOI_ZEROARR before including this library.
-- Data Format
A QOI file has a 14 byte header, followed by any number of data "chunks" and an
8-byte end marker.
struct qoi_header_t {
char magic[4]; // magic bytes "qoif"
uint32_t width; // image width in pixels (BE)
uint32_t height; // image height in pixels (BE)
uint8_t channels; // 3 = RGB, 4 = RGBA
uint8_t colorspace; // 0 = sRGB with linear alpha, 1 = all channels linear
};
Images are encoded row by row, left to right, top to bottom. The decoder and
encoder start with {r: 0, g: 0, b: 0, a: 255} as the previous pixel value. An
image is complete when all pixels specified by width * height have been covered.
Pixels are encoded as
- a run of the previous pixel
- an index into an array of previously seen pixels
- a difference to the previous pixel value in r,g,b
- full r,g,b or r,g,b,a values
The color channels are assumed to not be premultiplied with the alpha channel
("un-premultiplied alpha").
A running array[64] (zero-initialized) of previously seen pixel values is
maintained by the encoder and decoder. Each pixel that is seen by the encoder
and decoder is put into this array at the position formed by a hash function of
the color value. In the encoder, if the pixel value at the index matches the
current pixel, this index position is written to the stream as QOI_OP_INDEX.
The hash function for the index is:
index_position = (r * 3 + g * 5 + b * 7 + a * 11) % 64
Each chunk starts with a 2- or 8-bit tag, followed by a number of data bits. The
bit length of chunks is divisible by 8 - i.e. all chunks are byte aligned. All
values encoded in these data bits have the most significant bit on the left.
The 8-bit tags have precedence over the 2-bit tags. A decoder must check for the
presence of an 8-bit tag first.
The byte stream's end is marked with 7 0x00 bytes followed a single 0x01 byte.
The possible chunks are:
.- QOI_OP_INDEX ----------.
| Byte[0] |
| 7 6 5 4 3 2 1 0 |
|-------+-----------------|
| 0 0 | index |
`-------------------------`
2-bit tag b00
6-bit index into the color index array: 0..63
A valid encoder must not issue 2 or more consecutive QOI_OP_INDEX chunks to the
same index. QOI_OP_RUN should be used instead.
.- QOI_OP_DIFF -----------.
| Byte[0] |
| 7 6 5 4 3 2 1 0 |
|-------+-----+-----+-----|
| 0 1 | dr | dg | db |
`-------------------------`
2-bit tag b01
2-bit red channel difference from the previous pixel between -2..1
2-bit green channel difference from the previous pixel between -2..1
2-bit blue channel difference from the previous pixel between -2..1
The difference to the current channel values are using a wraparound operation,
so "1 - 2" will result in 255, while "255 + 1" will result in 0.
Values are stored as unsigned integers with a bias of 2. E.g. -2 is stored as
0 (b00). 1 is stored as 3 (b11).
The alpha value remains unchanged from the previous pixel.
.- QOI_OP_LUMA -------------------------------------.
| Byte[0] | Byte[1] |
| 7 6 5 4 3 2 1 0 | 7 6 5 4 3 2 1 0 |
|-------+-----------------+-------------+-----------|
| 1 0 | green diff | dr - dg | db - dg |
`---------------------------------------------------`
2-bit tag b10
6-bit green channel difference from the previous pixel -32..31
4-bit red channel difference minus green channel difference -8..7
4-bit blue channel difference minus green channel difference -8..7
The green channel is used to indicate the general direction of change and is
encoded in 6 bits. The red and blue channels (dr and db) base their diffs off
of the green channel difference and are encoded in 4 bits. I.e.:
dr_dg = (cur_px.r - prev_px.r) - (cur_px.g - prev_px.g)
db_dg = (cur_px.b - prev_px.b) - (cur_px.g - prev_px.g)
The difference to the current channel values are using a wraparound operation,
so "10 - 13" will result in 253, while "250 + 7" will result in 1.
Values are stored as unsigned integers with a bias of 32 for the green channel
and a bias of 8 for the red and blue channel.
The alpha value remains unchanged from the previous pixel.
.- QOI_OP_RUN ------------.
| Byte[0] |
| 7 6 5 4 3 2 1 0 |
|-------+-----------------|
| 1 1 | run |
`-------------------------`
2-bit tag b11
6-bit run-length repeating the previous pixel: 1..62
The run-length is stored with a bias of -1. Note that the run-lengths 63 and 64
(b111110 and b111111) are illegal as they are occupied by the QOI_OP_RGB and
QOI_OP_RGBA tags.
.- QOI_OP_RGB ------------------------------------------.
| Byte[0] | Byte[1] | Byte[2] | Byte[3] |
| 7 6 5 4 3 2 1 0 | 7 .. 0 | 7 .. 0 | 7 .. 0 |
|-------------------------+---------+---------+---------|
| 1 1 1 1 1 1 1 0 | red | green | blue |
`-------------------------------------------------------`
8-bit tag b11111110
8-bit red channel value
8-bit green channel value
8-bit blue channel value
The alpha value remains unchanged from the previous pixel.
.- QOI_OP_RGBA ---------------------------------------------------.
| Byte[0] | Byte[1] | Byte[2] | Byte[3] | Byte[4] |
| 7 6 5 4 3 2 1 0 | 7 .. 0 | 7 .. 0 | 7 .. 0 | 7 .. 0 |
|-------------------------+---------+---------+---------+---------|
| 1 1 1 1 1 1 1 1 | red | green | blue | alpha |
`-----------------------------------------------------------------`
8-bit tag b11111111
8-bit red channel value
8-bit green channel value
8-bit blue channel value
8-bit alpha channel value
*/
/* -----------------------------------------------------------------------------
Header - Public functions */
#ifndef QOI_H
#define QOI_H
#ifdef __cplusplus
extern "C" {
#endif
/* A pointer to a qoi_desc struct has to be supplied to all of qoi's functions.
It describes either the input format (for qoi_write and qoi_encode), or is
filled with the description read from the file header (for qoi_read and
qoi_decode).
The colorspace in this qoi_desc is an enum where
0 = sRGB, i.e. gamma scaled RGB channels and a linear alpha channel
1 = all channels are linear
You may use the constants QOI_SRGB or QOI_LINEAR. The colorspace is purely
informative. It will be saved to the file header, but does not affect
how chunks are en-/decoded. */
#define QOI_SRGB 0
#define QOI_LINEAR 1
typedef struct {
unsigned int width;
unsigned int height;
unsigned char channels;
unsigned char colorspace;
} qoi_desc;
#ifndef QOI_NO_STDIO
/* Encode raw RGB or RGBA pixels into a QOI image and write it to the file
system. The qoi_desc struct must be filled with the image width, height,
number of channels (3 = RGB, 4 = RGBA) and the colorspace.
The function returns 0 on failure (invalid parameters, or fopen or malloc
failed) or the number of bytes written on success. */
int qoi_write(const char *filename, const void *data, const qoi_desc *desc);
/* Read and decode a QOI image from the file system. If channels is 0, the
number of channels from the file header is used. If channels is 3 or 4 the
output format will be forced into this number of channels.
The function either returns NULL on failure (invalid data, or malloc or fopen
failed) or a pointer to the decoded pixels. On success, the qoi_desc struct
will be filled with the description from the file header.
The returned pixel data should be free()d after use. */
void *qoi_read(const char *filename, qoi_desc *desc, int channels);
#endif /* QOI_NO_STDIO */
/* Encode raw RGB or RGBA pixels into a QOI image in memory.
The function either returns NULL on failure (invalid parameters or malloc
failed) or a pointer to the encoded data on success. On success the out_len
is set to the size in bytes of the encoded data.
The returned qoi data should be free()d after use. */
void *qoi_encode(const void *data, const qoi_desc *desc, int *out_len);
/* Decode a QOI image from memory.
The function either returns NULL on failure (invalid parameters or malloc
failed) or a pointer to the decoded pixels. On success, the qoi_desc struct
is filled with the description from the file header.
The returned pixel data should be free()d after use. */
void *qoi_decode(const void *data, int size, qoi_desc *desc, int channels);
#ifdef __cplusplus
}
#endif
#endif /* QOI_H */
/* -----------------------------------------------------------------------------
Implementation */
#ifdef QOI_IMPLEMENTATION
#include <stdlib.h>
#include <string.h>
#ifndef QOI_MALLOC
#define QOI_MALLOC(sz) malloc(sz)
#define QOI_FREE(p) free(p)
#endif
#ifndef QOI_ZEROARR
#define QOI_ZEROARR(a) memset((a),0,sizeof(a))
#endif
#define QOI_OP_INDEX 0x00 /* 00xxxxxx */
#define QOI_OP_DIFF 0x40 /* 01xxxxxx */
#define QOI_OP_LUMA 0x80 /* 10xxxxxx */
#define QOI_OP_RUN 0xc0 /* 11xxxxxx */
#define QOI_OP_RGB 0xfe /* 11111110 */
#define QOI_OP_RGBA 0xff /* 11111111 */
#define QOI_MASK_2 0xc0 /* 11000000 */
#define QOI_COLOR_HASH(C) (C.rgba.r*3 + C.rgba.g*5 + C.rgba.b*7 + C.rgba.a*11)
#define QOI_MAGIC \
(((unsigned int)'q') << 24 | ((unsigned int)'o') << 16 | \
((unsigned int)'i') << 8 | ((unsigned int)'f'))
#define QOI_HEADER_SIZE 14
/* 2GB is the max file size that this implementation can safely handle. We guard
against anything larger than that, assuming the worst case with 5 bytes per
pixel, rounded down to a nice clean value. 400 million pixels ought to be
enough for anybody. */
#define QOI_PIXELS_MAX ((unsigned int)400000000)
typedef union {
struct { unsigned char r, g, b, a; } rgba;
unsigned int v;
} qoi_rgba_t;
static const unsigned char qoi_padding[8] = {0,0,0,0,0,0,0,1};
static void qoi_write_32(unsigned char *bytes, int *p, unsigned int v) {
bytes[(*p)++] = (0xff000000 & v) >> 24;
bytes[(*p)++] = (0x00ff0000 & v) >> 16;
bytes[(*p)++] = (0x0000ff00 & v) >> 8;
bytes[(*p)++] = (0x000000ff & v);
}
static unsigned int qoi_read_32(const unsigned char *bytes, int *p) {
unsigned int a = bytes[(*p)++];
unsigned int b = bytes[(*p)++];
unsigned int c = bytes[(*p)++];
unsigned int d = bytes[(*p)++];
return a << 24 | b << 16 | c << 8 | d;
}
void *qoi_encode(const void *data, const qoi_desc *desc, int *out_len) {
int i, max_size, p, run;
int px_len, px_end, px_pos, channels;
unsigned char *bytes;
const unsigned char *pixels;
qoi_rgba_t index[64];
qoi_rgba_t px, px_prev;
if (
data == NULL || out_len == NULL || desc == NULL ||
desc->width == 0 || desc->height == 0 ||
desc->channels < 3 || desc->channels > 4 ||
desc->colorspace > 1 ||
desc->height >= QOI_PIXELS_MAX / desc->width
) {
return NULL;
}
max_size =
desc->width * desc->height * (desc->channels + 1) +
QOI_HEADER_SIZE + sizeof(qoi_padding);
p = 0;
bytes = (unsigned char *) QOI_MALLOC(max_size);
if (!bytes) {
return NULL;
}
qoi_write_32(bytes, &p, QOI_MAGIC);
qoi_write_32(bytes, &p, desc->width);
qoi_write_32(bytes, &p, desc->height);
bytes[p++] = desc->channels;
bytes[p++] = desc->colorspace;
pixels = (const unsigned char *)data;
QOI_ZEROARR(index);
run = 0;
px_prev.rgba.r = 0;
px_prev.rgba.g = 0;
px_prev.rgba.b = 0;
px_prev.rgba.a = 255;
px = px_prev;
px_len = desc->width * desc->height * desc->channels;
px_end = px_len - desc->channels;
channels = desc->channels;
for (px_pos = 0; px_pos < px_len; px_pos += channels) {
px.rgba.r = pixels[px_pos + 0];
px.rgba.g = pixels[px_pos + 1];
px.rgba.b = pixels[px_pos + 2];
if (channels == 4) {
px.rgba.a = pixels[px_pos + 3];
}
if (px.v == px_prev.v) {
run++;
if (run == 62 || px_pos == px_end) {
bytes[p++] = QOI_OP_RUN | (run - 1);
run = 0;
}
}
else {
int index_pos;
if (run > 0) {
bytes[p++] = QOI_OP_RUN | (run - 1);
run = 0;
}
index_pos = QOI_COLOR_HASH(px) % 64;
if (index[index_pos].v == px.v) {
bytes[p++] = QOI_OP_INDEX | index_pos;
}
else {
index[index_pos] = px;
if (px.rgba.a == px_prev.rgba.a) {
signed char vr = px.rgba.r - px_prev.rgba.r;
signed char vg = px.rgba.g - px_prev.rgba.g;
signed char vb = px.rgba.b - px_prev.rgba.b;
signed char vg_r = vr - vg;
signed char vg_b = vb - vg;
if (
vr > -3 && vr < 2 &&
vg > -3 && vg < 2 &&
vb > -3 && vb < 2
) {
bytes[p++] = QOI_OP_DIFF | (vr + 2) << 4 | (vg + 2) << 2 | (vb + 2);
}
else if (
vg_r > -9 && vg_r < 8 &&
vg > -33 && vg < 32 &&
vg_b > -9 && vg_b < 8
) {
bytes[p++] = QOI_OP_LUMA | (vg + 32);
bytes[p++] = (vg_r + 8) << 4 | (vg_b + 8);
}
else {
bytes[p++] = QOI_OP_RGB;
bytes[p++] = px.rgba.r;
bytes[p++] = px.rgba.g;
bytes[p++] = px.rgba.b;
}
}
else {
bytes[p++] = QOI_OP_RGBA;
bytes[p++] = px.rgba.r;
bytes[p++] = px.rgba.g;
bytes[p++] = px.rgba.b;
bytes[p++] = px.rgba.a;
}
}
}
px_prev = px;
}
for (i = 0; i < (int)sizeof(qoi_padding); i++) {
bytes[p++] = qoi_padding[i];
}
*out_len = p;
return bytes;
}
void *qoi_decode(const void *data, int size, qoi_desc *desc, int channels) {
const unsigned char *bytes;
unsigned int header_magic;
unsigned char *pixels;
qoi_rgba_t index[64];
qoi_rgba_t px;
int px_len, chunks_len, px_pos;
int p = 0, run = 0;
if (
data == NULL || desc == NULL ||
(channels != 0 && channels != 3 && channels != 4) ||
size < QOI_HEADER_SIZE + (int)sizeof(qoi_padding)
) {
return NULL;
}
bytes = (const unsigned char *)data;
header_magic = qoi_read_32(bytes, &p);
desc->width = qoi_read_32(bytes, &p);
desc->height = qoi_read_32(bytes, &p);
desc->channels = bytes[p++];
desc->colorspace = bytes[p++];
if (
desc->width == 0 || desc->height == 0 ||
desc->channels < 3 || desc->channels > 4 ||
desc->colorspace > 1 ||
header_magic != QOI_MAGIC ||
desc->height >= QOI_PIXELS_MAX / desc->width
) {
return NULL;
}
if (channels == 0) {
channels = desc->channels;
}
px_len = desc->width * desc->height * channels;
pixels = (unsigned char *) QOI_MALLOC(px_len);
if (!pixels) {
return NULL;
}
QOI_ZEROARR(index);
px.rgba.r = 0;
px.rgba.g = 0;
px.rgba.b = 0;
px.rgba.a = 255;
chunks_len = size - (int)sizeof(qoi_padding);
for (px_pos = 0; px_pos < px_len; px_pos += channels) {
if (run > 0) {
run--;
}
else if (p < chunks_len) {
int b1 = bytes[p++];
if (b1 == QOI_OP_RGB) {
px.rgba.r = bytes[p++];
px.rgba.g = bytes[p++];
px.rgba.b = bytes[p++];
}
else if (b1 == QOI_OP_RGBA) {
px.rgba.r = bytes[p++];
px.rgba.g = bytes[p++];
px.rgba.b = bytes[p++];
px.rgba.a = bytes[p++];
}
else if ((b1 & QOI_MASK_2) == QOI_OP_INDEX) {
px = index[b1];
}
else if ((b1 & QOI_MASK_2) == QOI_OP_DIFF) {
px.rgba.r += ((b1 >> 4) & 0x03) - 2;
px.rgba.g += ((b1 >> 2) & 0x03) - 2;
px.rgba.b += ( b1 & 0x03) - 2;
}
else if ((b1 & QOI_MASK_2) == QOI_OP_LUMA) {
int b2 = bytes[p++];
int vg = (b1 & 0x3f) - 32;
px.rgba.r += vg - 8 + ((b2 >> 4) & 0x0f);
px.rgba.g += vg;
px.rgba.b += vg - 8 + (b2 & 0x0f);
}
else if ((b1 & QOI_MASK_2) == QOI_OP_RUN) {
run = (b1 & 0x3f);
}
index[QOI_COLOR_HASH(px) % 64] = px;
}
pixels[px_pos + 0] = px.rgba.r;
pixels[px_pos + 1] = px.rgba.g;
pixels[px_pos + 2] = px.rgba.b;
if (channels == 4) {
pixels[px_pos + 3] = px.rgba.a;
}
}
return pixels;
}
#ifndef QOI_NO_STDIO
#include <stdio.h>
int qoi_write(const char *filename, const void *data, const qoi_desc *desc) {
FILE *f = fopen(filename, "wb");
int size, err;
void *encoded;
if (!f) {
return 0;
}
encoded = qoi_encode(data, desc, &size);
if (!encoded) {
fclose(f);
return 0;
}
fwrite(encoded, 1, size, f);
fflush(f);
err = ferror(f);
fclose(f);
QOI_FREE(encoded);
return err ? 0 : size;
}
void *qoi_read(const char *filename, qoi_desc *desc, int channels) {
FILE *f = fopen(filename, "rb");
int size, bytes_read;
void *pixels, *data;
if (!f) {
return NULL;
}
fseek(f, 0, SEEK_END);
size = ftell(f);
if (size <= 0 || fseek(f, 0, SEEK_SET) != 0) {
fclose(f);
return NULL;
}
data = QOI_MALLOC(size);
if (!data) {
fclose(f);
return NULL;
}
bytes_read = fread(data, 1, size, f);
fclose(f);
pixels = (bytes_read != size) ? NULL : qoi_decode(data, bytes_read, desc, channels);
QOI_FREE(data);
return pixels;
}
#endif /* QOI_NO_STDIO */
#endif /* QOI_IMPLEMENTATION */

3
shared/audio_player.h
View file

@ -43,6 +43,9 @@ private:
void AudioThread();
int StartAudio(const std::string &filename);
void StopAudio();
};

172
shared/audio_player_raudio_impl.cpp Normal file
View file

@ -0,0 +1,172 @@
#include <functional>
#include <stdio.h>
#include "audio_player.h"
// #define MINIAUDIO_IMPLEMENTATION
// #include "miniaudio.h"
#include <SDL3/SDL.h>
#include <stdio.h>
#include "raudio.h"
static int audio_open = 0;
static int next_track = 0;
// static ma_result result;
// static ma_decoder decoder;
// static ma_device_config deviceConfig;
// static ma_device device;
SDL_AudioSpec spec;
static ThreadSafeQueue<AudioCommand> g_audioQueue;
// void data_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount)
// {
// ma_decoder* pDecoder = (ma_decoder*)pDevice->pUserData;
// if (pDecoder == NULL)
// {
// return;
// }
// if (ma_decoder_read_pcm_frames(pDecoder, pOutput, frameCount, NULL) != MA_SUCCESS)
// {
// g_audioQueue.push({"end", ""});
// }
// (void)pInput;
// }
static Music music;
static Sound sound;
AudioPlayer::AudioPlayer(IAudioEvent &event)
: m_event(event)
{
m_audioThread = std::thread( std::bind(&AudioPlayer::AudioThread, this) );
}
void AudioPlayer::Initialize()
{
InitAudioDevice();
audio_open = 1;
}
void AudioPlayer::Play(const std::string &filename)
{
// On coupe le son en cours
g_audioQueue.clear();
g_audioQueue.push({"play", filename});
}
AudioPlayer::~AudioPlayer()
{
// Quit audio thread
g_audioQueue.clear();
g_audioQueue.push({"quit", ""});
if (m_audioThread.joinable())
{
m_audioThread.join();
}
CloseAudioDevice();
}
int AudioPlayer::StartAudio(const std::string &filename)
{
// music = LoadMusicStream(filename.c_str());
// PlayMusicStream(music);
sound = LoadSound(filename.c_str());
PlaySound(sound);
/*
result = ma_decoder_init_file(filename.c_str(), NULL, &decoder);
if (result != MA_SUCCESS)
{
// FIXME: show error
return -1;
}
deviceConfig = ma_device_config_init(ma_device_type_playback);
deviceConfig.playback.format = decoder.outputFormat;
deviceConfig.playback.channels = decoder.outputChannels;
deviceConfig.sampleRate = decoder.outputSampleRate;
deviceConfig.dataCallback = data_callback;
deviceConfig.pUserData = &decoder;
if (ma_device_init(NULL, &deviceConfig, &device) != MA_SUCCESS)
{
printf("Failed to open playback device.\n");
ma_decoder_uninit(&decoder);
return -3;
}
if (ma_device_start(&device) != MA_SUCCESS)
{
printf("Failed to start playback device.\n");
StopAudio();
return -4;
}
*/
return 0;
}
void AudioPlayer::StopAudio()
{
// ma_device_uninit(&device);
// ma_decoder_uninit(&decoder);
StopSound(sound);
UnloadSound(sound);
// StopMusicStream(music);
// UnloadMusicStream(music);
}
void AudioPlayer::Stop()
{
g_audioQueue.clear();
g_audioQueue.push({"end", ""});
}
#define AUDIO_STATE_WAIT_PLAY 1
#define AUDIO_STATE_WAIT_END 2
void AudioPlayer::AudioThread()
{
int state = AUDIO_STATE_WAIT_PLAY;
for (;;)
{
auto cmd = g_audioQueue.front();
g_audioQueue.pop();
if (cmd.order == "quit")
{
return;
}
else if (cmd.order == "play")
{
if (state == AUDIO_STATE_WAIT_PLAY)
{
state = AUDIO_STATE_WAIT_END;
StartAudio(cmd.filename);
}
}
else if (cmd.order == "end")
{
if (state == AUDIO_STATE_WAIT_END)
{
state = AUDIO_STATE_WAIT_PLAY;
StopAudio();
m_event.EndOfAudio();
}
}
}
}

0
story-editor/src/base64.hpp → shared/base64.hpp
View file

2
shared/downloader.cpp
View file

@ -1,4 +1,4 @@
#include <mbedtls/aes.h>
// #include <mbedtls/aes.h>
#include "downloader.h"
#include "json.hpp"

0
story-editor/src/dr_mp3.h → shared/dr_mp3.h
View file

12536
shared/external/dr_flac.h vendored Normal file
View file

File diff suppressed because it is too large Load diff

4834
shared/external/dr_mp3.h vendored Normal file
View file

File diff suppressed because it is too large Load diff

8803
shared/external/dr_wav.h vendored Normal file
View file

File diff suppressed because it is too large Load diff

1596
shared/external/jar_mod.h vendored Normal file
View file

File diff suppressed because it is too large Load diff

2471
shared/external/jar_xm.h vendored Normal file
View file

File diff suppressed because it is too large Load diff

2
shared/miniaudio.h → shared/external/miniaudio.h vendored
View file

@ -92618,4 +92618,4 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
*/

728
shared/external/qoa.h vendored Normal file
View file

@ -0,0 +1,728 @@
/*
Copyright (c) 2023, Dominic Szablewski - https://phoboslab.org
SPDX-License-Identifier: MIT
QOA - The "Quite OK Audio" format for fast, lossy audio compression
-- Data Format
QOA encodes pulse-code modulated (PCM) audio data with up to 255 channels,
sample rates from 1 up to 16777215 hertz and a bit depth of 16 bits.
The compression method employed in QOA is lossy; it discards some information
from the uncompressed PCM data. For many types of audio signals this compression
is "transparent", i.e. the difference from the original file is often not
audible.
QOA encodes 20 samples of 16 bit PCM data into slices of 64 bits. A single
sample therefore requires 3.2 bits of storage space, resulting in a 5x
compression (16 / 3.2).
A QOA file consists of an 8 byte file header, followed by a number of frames.
Each frame contains an 8 byte frame header, the current 16 byte en-/decoder
state per channel and 256 slices per channel. Each slice is 8 bytes wide and
encodes 20 samples of audio data.
All values, including the slices, are big endian. The file layout is as follows:
struct {
struct {
char magic[4]; // magic bytes "qoaf"
uint32_t samples; // samples per channel in this file
} file_header;
struct {
struct {
uint8_t num_channels; // no. of channels
uint24_t samplerate; // samplerate in hz
uint16_t fsamples; // samples per channel in this frame
uint16_t fsize; // frame size (includes this header)
} frame_header;
struct {
int16_t history[4]; // most recent last
int16_t weights[4]; // most recent last
} lms_state[num_channels];
qoa_slice_t slices[256][num_channels];
} frames[ceil(samples / (256 * 20))];
} qoa_file_t;
Each `qoa_slice_t` contains a quantized scalefactor `sf_quant` and 20 quantized
residuals `qrNN`:
.- QOA_SLICE -- 64 bits, 20 samples --------------------------/ /------------.
| Byte[0] | Byte[1] | Byte[2] \ \ Byte[7] |
| 7 6 5 4 3 2 1 0 | 7 6 5 4 3 2 1 0 | 7 6 5 / / 2 1 0 |
|------------+--------+--------+--------+---------+---------+-\ \--+---------|
| sf_quant | qr00 | qr01 | qr02 | qr03 | qr04 | / / | qr19 |
`-------------------------------------------------------------\ \------------`
Each frame except the last must contain exactly 256 slices per channel. The last
frame may contain between 1 .. 256 (inclusive) slices per channel. The last
slice (for each channel) in the last frame may contain less than 20 samples; the
slice still must be 8 bytes wide, with the unused samples zeroed out.
Channels are interleaved per slice. E.g. for 2 channel stereo:
slice[0] = L, slice[1] = R, slice[2] = L, slice[3] = R ...
A valid QOA file or stream must have at least one frame. Each frame must contain
at least one channel and one sample with a samplerate between 1 .. 16777215
(inclusive).
If the total number of samples is not known by the encoder, the samples in the
file header may be set to 0x00000000 to indicate that the encoder is
"streaming". In a streaming context, the samplerate and number of channels may
differ from frame to frame. For static files (those with samples set to a
non-zero value), each frame must have the same number of channels and same
samplerate.
Note that this implementation of QOA only handles files with a known total
number of samples.
A decoder should support at least 8 channels. The channel layout for channel
counts 1 .. 8 is:
1. Mono
2. L, R
3. L, R, C
4. FL, FR, B/SL, B/SR
5. FL, FR, C, B/SL, B/SR
6. FL, FR, C, LFE, B/SL, B/SR
7. FL, FR, C, LFE, B, SL, SR
8. FL, FR, C, LFE, BL, BR, SL, SR
QOA predicts each audio sample based on the previously decoded ones using a
"Sign-Sign Least Mean Squares Filter" (LMS). This prediction plus the
dequantized residual forms the final output sample.
*/
/* -----------------------------------------------------------------------------
Header - Public functions */
#ifndef QOA_H
#define QOA_H
#ifdef __cplusplus
extern "C" {
#endif
#define QOA_MIN_FILESIZE 16
#define QOA_MAX_CHANNELS 8
#define QOA_SLICE_LEN 20
#define QOA_SLICES_PER_FRAME 256
#define QOA_FRAME_LEN (QOA_SLICES_PER_FRAME * QOA_SLICE_LEN)
#define QOA_LMS_LEN 4
#define QOA_MAGIC 0x716f6166 /* 'qoaf' */
#define QOA_FRAME_SIZE(channels, slices) \
(8 + QOA_LMS_LEN * 4 * channels + 8 * slices * channels)
typedef struct {
int history[QOA_LMS_LEN];
int weights[QOA_LMS_LEN];
} qoa_lms_t;
typedef struct {
unsigned int channels;
unsigned int samplerate;
unsigned int samples;
qoa_lms_t lms[QOA_MAX_CHANNELS];
#ifdef QOA_RECORD_TOTAL_ERROR
double error;
#endif
} qoa_desc;
unsigned int qoa_encode_header(qoa_desc *qoa, unsigned char *bytes);
unsigned int qoa_encode_frame(const short *sample_data, qoa_desc *qoa, unsigned int frame_len, unsigned char *bytes);
void *qoa_encode(const short *sample_data, qoa_desc *qoa, unsigned int *out_len);
unsigned int qoa_max_frame_size(qoa_desc *qoa);
unsigned int qoa_decode_header(const unsigned char *bytes, int size, qoa_desc *qoa);
unsigned int qoa_decode_frame(const unsigned char *bytes, unsigned int size, qoa_desc *qoa, short *sample_data, unsigned int *frame_len);
short *qoa_decode(const unsigned char *bytes, int size, qoa_desc *file);
#ifndef QOA_NO_STDIO
int qoa_write(const char *filename, const short *sample_data, qoa_desc *qoa);
void *qoa_read(const char *filename, qoa_desc *qoa);
#endif /* QOA_NO_STDIO */
#ifdef __cplusplus
}
#endif
#endif /* QOA_H */
/* -----------------------------------------------------------------------------
Implementation */
#ifdef QOA_IMPLEMENTATION
#include <stdlib.h>
#ifndef QOA_MALLOC
#define QOA_MALLOC(sz) malloc(sz)
#define QOA_FREE(p) free(p)
#endif
typedef unsigned long long qoa_uint64_t;
/* The quant_tab provides an index into the dequant_tab for residuals in the
range of -8 .. 8. It maps this range to just 3bits and becomes less accurate at
the higher end. Note that the residual zero is identical to the lowest positive
value. This is mostly fine, since the qoa_div() function always rounds away
from zero. */
static const int qoa_quant_tab[17] = {
7, 7, 7, 5, 5, 3, 3, 1, /* -8..-1 */
0, /* 0 */
0, 2, 2, 4, 4, 6, 6, 6 /* 1.. 8 */
};
/* We have 16 different scalefactors. Like the quantized residuals these become
less accurate at the higher end. In theory, the highest scalefactor that we
would need to encode the highest 16bit residual is (2**16)/8 = 8192. However we
rely on the LMS filter to predict samples accurately enough that a maximum
residual of one quarter of the 16 bit range is sufficient. I.e. with the
scalefactor 2048 times the quant range of 8 we can encode residuals up to 2**14.
The scalefactor values are computed as:
scalefactor_tab[s] <- round(pow(s + 1, 2.75)) */
static const int qoa_scalefactor_tab[16] = {
1, 7, 21, 45, 84, 138, 211, 304, 421, 562, 731, 928, 1157, 1419, 1715, 2048
};
/* The reciprocal_tab maps each of the 16 scalefactors to their rounded
reciprocals 1/scalefactor. This allows us to calculate the scaled residuals in
the encoder with just one multiplication instead of an expensive division. We
do this in .16 fixed point with integers, instead of floats.
The reciprocal_tab is computed as:
reciprocal_tab[s] <- ((1<<16) + scalefactor_tab[s] - 1) / scalefactor_tab[s] */
static const int qoa_reciprocal_tab[16] = {
65536, 9363, 3121, 1457, 781, 475, 311, 216, 156, 117, 90, 71, 57, 47, 39, 32
};
/* The dequant_tab maps each of the scalefactors and quantized residuals to
their unscaled & dequantized version.
Since qoa_div rounds away from the zero, the smallest entries are mapped to 3/4
instead of 1. The dequant_tab assumes the following dequantized values for each
of the quant_tab indices and is computed as:
float dqt[8] = {0.75, -0.75, 2.5, -2.5, 4.5, -4.5, 7, -7};
dequant_tab[s][q] <- round_ties_away_from_zero(scalefactor_tab[s] * dqt[q])
The rounding employed here is "to nearest, ties away from zero", i.e. positive
and negative values are treated symmetrically.
*/
static const int qoa_dequant_tab[16][8] = {
{ 1, -1, 3, -3, 5, -5, 7, -7},
{ 5, -5, 18, -18, 32, -32, 49, -49},
{ 16, -16, 53, -53, 95, -95, 147, -147},
{ 34, -34, 113, -113, 203, -203, 315, -315},
{ 63, -63, 210, -210, 378, -378, 588, -588},
{ 104, -104, 345, -345, 621, -621, 966, -966},
{ 158, -158, 528, -528, 950, -950, 1477, -1477},
{ 228, -228, 760, -760, 1368, -1368, 2128, -2128},
{ 316, -316, 1053, -1053, 1895, -1895, 2947, -2947},
{ 422, -422, 1405, -1405, 2529, -2529, 3934, -3934},
{ 548, -548, 1828, -1828, 3290, -3290, 5117, -5117},
{ 696, -696, 2320, -2320, 4176, -4176, 6496, -6496},
{ 868, -868, 2893, -2893, 5207, -5207, 8099, -8099},
{1064, -1064, 3548, -3548, 6386, -6386, 9933, -9933},
{1286, -1286, 4288, -4288, 7718, -7718, 12005, -12005},
{1536, -1536, 5120, -5120, 9216, -9216, 14336, -14336},
};
/* The Least Mean Squares Filter is the heart of QOA. It predicts the next
sample based on the previous 4 reconstructed samples. It does so by continuously
adjusting 4 weights based on the residual of the previous prediction.
The next sample is predicted as the sum of (weight[i] * history[i]).
The adjustment of the weights is done with a "Sign-Sign-LMS" that adds or
subtracts the residual to each weight, based on the corresponding sample from
the history. This, surprisingly, is sufficient to get worthwhile predictions.
This is all done with fixed point integers. Hence the right-shifts when updating
the weights and calculating the prediction. */
static int qoa_lms_predict(qoa_lms_t *lms) {
int prediction = 0;
for (int i = 0; i < QOA_LMS_LEN; i++) {
prediction += lms->weights[i] * lms->history[i];
}
return prediction >> 13;
}
static void qoa_lms_update(qoa_lms_t *lms, int sample, int residual) {
int delta = residual >> 4;
for (int i = 0; i < QOA_LMS_LEN; i++) {
lms->weights[i] += lms->history[i] < 0 ? -delta : delta;
}
for (int i = 0; i < QOA_LMS_LEN-1; i++) {
lms->history[i] = lms->history[i+1];
}
lms->history[QOA_LMS_LEN-1] = sample;
}
/* qoa_div() implements a rounding division, but avoids rounding to zero for
small numbers. E.g. 0.1 will be rounded to 1. Note that 0 itself still
returns as 0, which is handled in the qoa_quant_tab[].
qoa_div() takes an index into the .16 fixed point qoa_reciprocal_tab as an
argument, so it can do the division with a cheaper integer multiplication. */
static inline int qoa_div(int v, int scalefactor) {
int reciprocal = qoa_reciprocal_tab[scalefactor];
int n = (v * reciprocal + (1 << 15)) >> 16;
n = n + ((v > 0) - (v < 0)) - ((n > 0) - (n < 0)); /* round away from 0 */
return n;
}
static inline int qoa_clamp(int v, int min, int max) {
if (v < min) { return min; }
if (v > max) { return max; }
return v;
}
/* This specialized clamp function for the signed 16 bit range improves decode
performance quite a bit. The extra if() statement works nicely with the CPUs
branch prediction as this branch is rarely taken. */
static inline int qoa_clamp_s16(int v) {
if ((unsigned int)(v + 32768) > 65535) {
if (v < -32768) { return -32768; }
if (v > 32767) { return 32767; }
}
return v;
}
static inline qoa_uint64_t qoa_read_u64(const unsigned char *bytes, unsigned int *p) {
bytes += *p;
*p += 8;
return
((qoa_uint64_t)(bytes[0]) << 56) | ((qoa_uint64_t)(bytes[1]) << 48) |
((qoa_uint64_t)(bytes[2]) << 40) | ((qoa_uint64_t)(bytes[3]) << 32) |
((qoa_uint64_t)(bytes[4]) << 24) | ((qoa_uint64_t)(bytes[5]) << 16) |
((qoa_uint64_t)(bytes[6]) << 8) | ((qoa_uint64_t)(bytes[7]) << 0);
}
static inline void qoa_write_u64(qoa_uint64_t v, unsigned char *bytes, unsigned int *p) {
bytes += *p;
*p += 8;
bytes[0] = (v >> 56) & 0xff;
bytes[1] = (v >> 48) & 0xff;
bytes[2] = (v >> 40) & 0xff;
bytes[3] = (v >> 32) & 0xff;
bytes[4] = (v >> 24) & 0xff;
bytes[5] = (v >> 16) & 0xff;
bytes[6] = (v >> 8) & 0xff;
bytes[7] = (v >> 0) & 0xff;
}
/* -----------------------------------------------------------------------------
Encoder */
unsigned int qoa_encode_header(qoa_desc *qoa, unsigned char *bytes) {
unsigned int p = 0;
qoa_write_u64(((qoa_uint64_t)QOA_MAGIC << 32) | qoa->samples, bytes, &p);
return p;
}
unsigned int qoa_encode_frame(const short *sample_data, qoa_desc *qoa, unsigned int frame_len, unsigned char *bytes) {
unsigned int channels = qoa->channels;
unsigned int p = 0;
unsigned int slices = (frame_len + QOA_SLICE_LEN - 1) / QOA_SLICE_LEN;
unsigned int frame_size = QOA_FRAME_SIZE(channels, slices);
int prev_scalefactor[QOA_MAX_CHANNELS] = {0};
/* Write the frame header */
qoa_write_u64((
(qoa_uint64_t)qoa->channels << 56 |
(qoa_uint64_t)qoa->samplerate << 32 |
(qoa_uint64_t)frame_len << 16 |
(qoa_uint64_t)frame_size
), bytes, &p);
for (int c = 0; c < channels; c++) {
/* If the weights have grown too large, reset them to 0. This may happen
with certain high-frequency sounds. This is a last resort and will
introduce quite a bit of noise, but should at least prevent pops/clicks */
int weights_sum =
qoa->lms[c].weights[0] * qoa->lms[c].weights[0] +
qoa->lms[c].weights[1] * qoa->lms[c].weights[1] +
qoa->lms[c].weights[2] * qoa->lms[c].weights[2] +
qoa->lms[c].weights[3] * qoa->lms[c].weights[3];
if (weights_sum > 0x2fffffff) {
qoa->lms[c].weights[0] = 0;
qoa->lms[c].weights[1] = 0;
qoa->lms[c].weights[2] = 0;
qoa->lms[c].weights[3] = 0;
}
/* Write the current LMS state */
qoa_uint64_t weights = 0;
qoa_uint64_t history = 0;
for (int i = 0; i < QOA_LMS_LEN; i++) {
history = (history << 16) | (qoa->lms[c].history[i] & 0xffff);
weights = (weights << 16) | (qoa->lms[c].weights[i] & 0xffff);
}
qoa_write_u64(history, bytes, &p);
qoa_write_u64(weights, bytes, &p);
}
/* We encode all samples with the channels interleaved on a slice level.
E.g. for stereo: (ch-0, slice 0), (ch 1, slice 0), (ch 0, slice 1), ...*/
for (int sample_index = 0; sample_index < frame_len; sample_index += QOA_SLICE_LEN) {
for (int c = 0; c < channels; c++) {
int slice_len = qoa_clamp(QOA_SLICE_LEN, 0, frame_len - sample_index);
int slice_start = sample_index * channels + c;
int slice_end = (sample_index + slice_len) * channels + c;
/* Brute for search for the best scalefactor. Just go through all
16 scalefactors, encode all samples for the current slice and
meassure the total squared error. */
qoa_uint64_t best_error = -1;
qoa_uint64_t best_slice;
qoa_lms_t best_lms;
int best_scalefactor;
for (int sfi = 0; sfi < 16; sfi++) {
/* There is a strong correlation between the scalefactors of
neighboring slices. As an optimization, start testing
the best scalefactor of the previous slice first. */
int scalefactor = (sfi + prev_scalefactor[c]) % 16;
/* We have to reset the LMS state to the last known good one
before trying each scalefactor, as each pass updates the LMS
state when encoding. */
qoa_lms_t lms = qoa->lms[c];
qoa_uint64_t slice = scalefactor;
qoa_uint64_t current_error = 0;
for (int si = slice_start; si < slice_end; si += channels) {
int sample = sample_data[si];
int predicted = qoa_lms_predict(&lms);
int residual = sample - predicted;
int scaled = qoa_div(residual, scalefactor);
int clamped = qoa_clamp(scaled, -8, 8);
int quantized = qoa_quant_tab[clamped + 8];
int dequantized = qoa_dequant_tab[scalefactor][quantized];
int reconstructed = qoa_clamp_s16(predicted + dequantized);
long long error = (sample - reconstructed);
current_error += error * error;
if (current_error > best_error) {
break;
}
qoa_lms_update(&lms, reconstructed, dequantized);
slice = (slice << 3) | quantized;
}
if (current_error < best_error) {
best_error = current_error;
best_slice = slice;
best_lms = lms;
best_scalefactor = scalefactor;
}
}
prev_scalefactor[c] = best_scalefactor;
qoa->lms[c] = best_lms;
#ifdef QOA_RECORD_TOTAL_ERROR
qoa->error += best_error;
#endif
/* If this slice was shorter than QOA_SLICE_LEN, we have to left-
shift all encoded data, to ensure the rightmost bits are the empty
ones. This should only happen in the last frame of a file as all
slices are completely filled otherwise. */
best_slice <<= (QOA_SLICE_LEN - slice_len) * 3;
qoa_write_u64(best_slice, bytes, &p);
}
}
return p;
}
void *qoa_encode(const short *sample_data, qoa_desc *qoa, unsigned int *out_len) {
if (
qoa->samples == 0 ||
qoa->samplerate == 0 || qoa->samplerate > 0xffffff ||
qoa->channels == 0 || qoa->channels > QOA_MAX_CHANNELS
) {
return NULL;
}
/* Calculate the encoded size and allocate */
unsigned int num_frames = (qoa->samples + QOA_FRAME_LEN-1) / QOA_FRAME_LEN;
unsigned int num_slices = (qoa->samples + QOA_SLICE_LEN-1) / QOA_SLICE_LEN;
unsigned int encoded_size = 8 + /* 8 byte file header */
num_frames * 8 + /* 8 byte frame headers */
num_frames * QOA_LMS_LEN * 4 * qoa->channels + /* 4 * 4 bytes lms state per channel */
num_slices * 8 * qoa->channels; /* 8 byte slices */
unsigned char *bytes = QOA_MALLOC(encoded_size);
for (int c = 0; c < qoa->channels; c++) {
/* Set the initial LMS weights to {0, 0, -1, 2}. This helps with the
prediction of the first few ms of a file. */
qoa->lms[c].weights[0] = 0;
qoa->lms[c].weights[1] = 0;
qoa->lms[c].weights[2] = -(1<<13);
qoa->lms[c].weights[3] = (1<<14);
/* Explicitly set the history samples to 0, as we might have some
garbage in there. */
for (int i = 0; i < QOA_LMS_LEN; i++) {
qoa->lms[c].history[i] = 0;
}
}
/* Encode the header and go through all frames */
unsigned int p = qoa_encode_header(qoa, bytes);
#ifdef QOA_RECORD_TOTAL_ERROR
qoa->error = 0;
#endif
int frame_len = QOA_FRAME_LEN;
for (int sample_index = 0; sample_index < qoa->samples; sample_index += frame_len) {
frame_len = qoa_clamp(QOA_FRAME_LEN, 0, qoa->samples - sample_index);
const short *frame_samples = sample_data + sample_index * qoa->channels;
unsigned int frame_size = qoa_encode_frame(frame_samples, qoa, frame_len, bytes + p);
p += frame_size;
}
*out_len = p;
return bytes;
}
/* -----------------------------------------------------------------------------
Decoder */
unsigned int qoa_max_frame_size(qoa_desc *qoa) {
return QOA_FRAME_SIZE(qoa->channels, QOA_SLICES_PER_FRAME);
}
unsigned int qoa_decode_header(const unsigned char *bytes, int size, qoa_desc *qoa) {
unsigned int p = 0;
if (size < QOA_MIN_FILESIZE) {
return 0;
}
/* Read the file header, verify the magic number ('qoaf') and read the
total number of samples. */
qoa_uint64_t file_header = qoa_read_u64(bytes, &p);
if ((file_header >> 32) != QOA_MAGIC) {
return 0;
}
qoa->samples = file_header & 0xffffffff;
if (!qoa->samples) {
return 0;
}
/* Peek into the first frame header to get the number of channels and
the samplerate. */
qoa_uint64_t frame_header = qoa_read_u64(bytes, &p);
qoa->channels = (frame_header >> 56) & 0x0000ff;
qoa->samplerate = (frame_header >> 32) & 0xffffff;
if (qoa->channels == 0 || qoa->samples == 0 || qoa->samplerate == 0) {
return 0;
}
return 8;
}
unsigned int qoa_decode_frame(const unsigned char *bytes, unsigned int size, qoa_desc *qoa, short *sample_data, unsigned int *frame_len) {
unsigned int p = 0;
*frame_len = 0;
if (size < 8 + QOA_LMS_LEN * 4 * qoa->channels) {
return 0;
}
/* Read and verify the frame header */
qoa_uint64_t frame_header = qoa_read_u64(bytes, &p);
int channels = (frame_header >> 56) & 0x0000ff;
int samplerate = (frame_header >> 32) & 0xffffff;
int samples = (frame_header >> 16) & 0x00ffff;
int frame_size = (frame_header ) & 0x00ffff;
int data_size = frame_size - 8 - QOA_LMS_LEN * 4 * channels;
int num_slices = data_size / 8;
int max_total_samples = num_slices * QOA_SLICE_LEN;
if (
channels != qoa->channels ||
samplerate != qoa->samplerate ||
frame_size > size ||
samples * channels > max_total_samples
) {
return 0;
}
/* Read the LMS state: 4 x 2 bytes history, 4 x 2 bytes weights per channel */
for (int c = 0; c < channels; c++) {
qoa_uint64_t history = qoa_read_u64(bytes, &p);
qoa_uint64_t weights = qoa_read_u64(bytes, &p);
for (int i = 0; i < QOA_LMS_LEN; i++) {
qoa->lms[c].history[i] = ((signed short)(history >> 48));
history <<= 16;
qoa->lms[c].weights[i] = ((signed short)(weights >> 48));
weights <<= 16;
}
}
/* Decode all slices for all channels in this frame */
for (int sample_index = 0; sample_index < samples; sample_index += QOA_SLICE_LEN) {
for (int c = 0; c < channels; c++) {
qoa_uint64_t slice = qoa_read_u64(bytes, &p);
int scalefactor = (slice >> 60) & 0xf;
int slice_start = sample_index * channels + c;
int slice_end = qoa_clamp(sample_index + QOA_SLICE_LEN, 0, samples) * channels + c;
for (int si = slice_start; si < slice_end; si += channels) {
int predicted = qoa_lms_predict(&qoa->lms[c]);
int quantized = (slice >> 57) & 0x7;
int dequantized = qoa_dequant_tab[scalefactor][quantized];
int reconstructed = qoa_clamp_s16(predicted + dequantized);
sample_data[si] = reconstructed;
slice <<= 3;
qoa_lms_update(&qoa->lms[c], reconstructed, dequantized);
}
}
}
*frame_len = samples;
return p;
}
short *qoa_decode(const unsigned char *bytes, int size, qoa_desc *qoa) {
unsigned int p = qoa_decode_header(bytes, size, qoa);
if (!p) {
return NULL;
}
/* Calculate the required size of the sample buffer and allocate */
int total_samples = qoa->samples * qoa->channels;
short *sample_data = QOA_MALLOC(total_samples * sizeof(short));
unsigned int sample_index = 0;
unsigned int frame_len;
unsigned int frame_size;
/* Decode all frames */
do {
short *sample_ptr = sample_data + sample_index * qoa->channels;
frame_size = qoa_decode_frame(bytes + p, size - p, qoa, sample_ptr, &frame_len);
p += frame_size;
sample_index += frame_len;
} while (frame_size && sample_index < qoa->samples);
qoa->samples = sample_index;
return sample_data;
}
/* -----------------------------------------------------------------------------
File read/write convenience functions */
#ifndef QOA_NO_STDIO
#include <stdio.h>
int qoa_write(const char *filename, const short *sample_data, qoa_desc *qoa) {
FILE *f = fopen(filename, "wb");
unsigned int size;
void *encoded;
if (!f) {
return 0;
}
encoded = qoa_encode(sample_data, qoa, &size);
if (!encoded) {
fclose(f);
return 0;
}
fwrite(encoded, 1, size, f);
fclose(f);
QOA_FREE(encoded);
return size;
}
void *qoa_read(const char *filename, qoa_desc *qoa) {
FILE *f = fopen(filename, "rb");
int size, bytes_read;
void *data;
short *sample_data;
if (!f) {
return NULL;
}
fseek(f, 0, SEEK_END);
size = ftell(f);
if (size <= 0) {
fclose(f);
return NULL;
}
fseek(f, 0, SEEK_SET);
data = QOA_MALLOC(size);
if (!data) {
fclose(f);
return NULL;
}
bytes_read = fread(data, 1, size, f);
fclose(f);
sample_data = qoa_decode(data, bytes_read, qoa);
QOA_FREE(data);
return sample_data;
}
#endif /* QOA_NO_STDIO */
#endif /* QOA_IMPLEMENTATION */

278
shared/external/qoaplay.c vendored Normal file
View file

@ -0,0 +1,278 @@
/*******************************************************************************************
*
* qoaplay - QOA stream playing helper functions
*
* qoaplay is a tiny abstraction to read and decode a QOA file "on the fly".
* It reads and decodes one frame at a time with minimal memory requirements.
* qoaplay also provides some functions to seek to a specific frame.
*
* LICENSE: MIT License
*
* Copyright (c) 2023 Dominic Szablewski (@phoboslab), reviewed by Ramon Santamaria (@raysan5)
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
**********************************************************************************************/
//----------------------------------------------------------------------------------
// Types and Structures Definition
//----------------------------------------------------------------------------------
// QOA streaming data descriptor
typedef struct {
qoa_desc info; // QOA descriptor data
FILE *file; // QOA file to read, if NULL, using memory buffer -> file_data
unsigned char *file_data; // QOA file data on memory
unsigned int file_data_size; // QOA file data on memory size
unsigned int file_data_offset; // QOA file data on memory offset for next read
unsigned int first_frame_pos; // First frame position (after QOA header, required for offset)
unsigned int sample_position; // Current streaming sample position
unsigned char *buffer; // Buffer used to read samples from file/memory (used on decoding)
unsigned int buffer_len; // Buffer length to read samples for streaming
short *sample_data; // Sample data decoded
unsigned int sample_data_len; // Sample data decoded length
unsigned int sample_data_pos; // Sample data decoded position
} qoaplay_desc;
//----------------------------------------------------------------------------------
// Module Functions Declaration
//----------------------------------------------------------------------------------
#if defined(__cplusplus)
extern "C" { // Prevents name mangling of functions
#endif
qoaplay_desc *qoaplay_open(const char *path);
qoaplay_desc *qoaplay_open_memory(const unsigned char *data, int data_size);
void qoaplay_close(qoaplay_desc *qoa_ctx);
void qoaplay_rewind(qoaplay_desc *qoa_ctx);
void qoaplay_seek_frame(qoaplay_desc *qoa_ctx, int frame);
unsigned int qoaplay_decode(qoaplay_desc *qoa_ctx, float *sample_data, int num_samples);
unsigned int qoaplay_decode_frame(qoaplay_desc *qoa_ctx);
double qoaplay_get_duration(qoaplay_desc *qoa_ctx);
double qoaplay_get_time(qoaplay_desc *qoa_ctx);
int qoaplay_get_frame(qoaplay_desc *qoa_ctx);
#if defined(__cplusplus)
} // Prevents name mangling of functions
#endif
//----------------------------------------------------------------------------------
// Module Functions Definition
//----------------------------------------------------------------------------------
// Open QOA file, keep FILE pointer to keep reading from file
qoaplay_desc *qoaplay_open(const char *path)
{
FILE *file = fopen(path, "rb");
if (!file) return NULL;
// Read and decode the file header
unsigned char header[QOA_MIN_FILESIZE];
int read = fread(header, QOA_MIN_FILESIZE, 1, file);
if (!read) return NULL;
qoa_desc qoa;
unsigned int first_frame_pos = qoa_decode_header(header, QOA_MIN_FILESIZE, &qoa);
if (!first_frame_pos) return NULL;
// Rewind the file back to beginning of the first frame
fseek(file, first_frame_pos, SEEK_SET);
// Allocate one chunk of memory for the qoaplay_desc struct
// + the sample data for one frame
// + a buffer to hold one frame of encoded data
unsigned int buffer_size = qoa_max_frame_size(&qoa);
unsigned int sample_data_size = qoa.channels*QOA_FRAME_LEN*sizeof(short)*2;
qoaplay_desc *qoa_ctx = QOA_MALLOC(sizeof(qoaplay_desc) + buffer_size + sample_data_size);
memset(qoa_ctx, 0, sizeof(qoaplay_desc));
qoa_ctx->file = file;
qoa_ctx->file_data = NULL;
qoa_ctx->file_data_size = 0;
qoa_ctx->file_data_offset = 0;
qoa_ctx->first_frame_pos = first_frame_pos;
// Setup data pointers to previously allocated data
qoa_ctx->buffer = ((unsigned char *)qoa_ctx) + sizeof(qoaplay_desc);
qoa_ctx->sample_data = (short *)(((unsigned char *)qoa_ctx) + sizeof(qoaplay_desc) + buffer_size);
qoa_ctx->info.channels = qoa.channels;
qoa_ctx->info.samplerate = qoa.samplerate;
qoa_ctx->info.samples = qoa.samples;
return qoa_ctx;
}
// Open QOA file from memory, no FILE pointer required
qoaplay_desc *qoaplay_open_memory(const unsigned char *data, int data_size)
{
// Read and decode the file header
unsigned char header[QOA_MIN_FILESIZE];
memcpy(header, data, QOA_MIN_FILESIZE);
qoa_desc qoa;
unsigned int first_frame_pos = qoa_decode_header(header, QOA_MIN_FILESIZE, &qoa);
if (!first_frame_pos) return NULL;
// Allocate one chunk of memory for the qoaplay_desc struct
// + the sample data for one frame
// + a buffer to hold one frame of encoded data
unsigned int buffer_size = qoa_max_frame_size(&qoa);
unsigned int sample_data_size = qoa.channels*QOA_FRAME_LEN*sizeof(short)*2;
qoaplay_desc *qoa_ctx = QOA_MALLOC(sizeof(qoaplay_desc) + buffer_size + sample_data_size);
memset(qoa_ctx, 0, sizeof(qoaplay_desc));
qoa_ctx->file = NULL;
// Keep a copy of file data provided to be managed internally
qoa_ctx->file_data = (unsigned char *)QOA_MALLOC(data_size);
memcpy(qoa_ctx->file_data, data, data_size);
qoa_ctx->file_data_size = data_size;
qoa_ctx->file_data_offset = 0;
qoa_ctx->first_frame_pos = first_frame_pos;
// Setup data pointers to previously allocated data
qoa_ctx->buffer = ((unsigned char *)qoa_ctx) + sizeof(qoaplay_desc);
qoa_ctx->sample_data = (short *)(((unsigned char *)qoa_ctx) + sizeof(qoaplay_desc) + buffer_size);
qoa_ctx->info.channels = qoa.channels;
qoa_ctx->info.samplerate = qoa.samplerate;
qoa_ctx->info.samples = qoa.samples;
return qoa_ctx;
}
// Close QOA file (if open) and free internal memory
void qoaplay_close(qoaplay_desc *qoa_ctx)
{
if (qoa_ctx->file) fclose(qoa_ctx->file);
if ((qoa_ctx->file_data) && (qoa_ctx->file_data_size > 0))
{
QOA_FREE(qoa_ctx->file_data);
qoa_ctx->file_data_size = 0;
}
QOA_FREE(qoa_ctx);
}
// Decode one frame from QOA data
unsigned int qoaplay_decode_frame(qoaplay_desc *qoa_ctx)
{
if (qoa_ctx->file) qoa_ctx->buffer_len = fread(qoa_ctx->buffer, 1, qoa_max_frame_size(&qoa_ctx->info), qoa_ctx->file);
else
{
qoa_ctx->buffer_len = qoa_max_frame_size(&qoa_ctx->info);
memcpy(qoa_ctx->buffer, qoa_ctx->file_data + qoa_ctx->file_data_offset, qoa_ctx->buffer_len);
qoa_ctx->file_data_offset += qoa_ctx->buffer_len;
}
unsigned int frame_len;
qoa_decode_frame(qoa_ctx->buffer, qoa_ctx->buffer_len, &qoa_ctx->info, qoa_ctx->sample_data, &frame_len);
qoa_ctx->sample_data_pos = 0;
qoa_ctx->sample_data_len = frame_len;
return frame_len;
}
// Rewind QOA file or memory pointer to beginning
void qoaplay_rewind(qoaplay_desc *qoa_ctx)
{
if (qoa_ctx->file) fseek(qoa_ctx->file, qoa_ctx->first_frame_pos, SEEK_SET);
else qoa_ctx->file_data_offset = 0;
qoa_ctx->sample_position = 0;
qoa_ctx->sample_data_len = 0;
qoa_ctx->sample_data_pos = 0;
}
// Decode required QOA frames
unsigned int qoaplay_decode(qoaplay_desc *qoa_ctx, float *sample_data, int num_samples)
{
int src_index = qoa_ctx->sample_data_pos*qoa_ctx->info.channels;
int dst_index = 0;
for (int i = 0; i < num_samples; i++)
{
// Do we have to decode more samples?
if (qoa_ctx->sample_data_len - qoa_ctx->sample_data_pos == 0)
{
if (!qoaplay_decode_frame(qoa_ctx))
{
// Loop to the beginning
qoaplay_rewind(qoa_ctx);
qoaplay_decode_frame(qoa_ctx);
}
src_index = 0;
}
// Normalize to -1..1 floats and write to dest
for (int c = 0; c < qoa_ctx->info.channels; c++)
{
sample_data[dst_index++] = qoa_ctx->sample_data[src_index++]/32768.0;
}
qoa_ctx->sample_data_pos++;
qoa_ctx->sample_position++;
}
return num_samples;
}
// Get QOA total time duration in seconds
double qoaplay_get_duration(qoaplay_desc *qoa_ctx)
{
return (double)qoa_ctx->info.samples/(double)qoa_ctx->info.samplerate;
}
// Get QOA current time position in seconds
double qoaplay_get_time(qoaplay_desc *qoa_ctx)
{
return (double)qoa_ctx->sample_position/(double)qoa_ctx->info.samplerate;
}
// Get QOA current audio frame
int qoaplay_get_frame(qoaplay_desc *qoa_ctx)
{
return qoa_ctx->sample_position/QOA_FRAME_LEN;
}
// Seek QOA audio frame
void qoaplay_seek_frame(qoaplay_desc *qoa_ctx, int frame)
{
if (frame < 0) frame = 0;
if (frame > qoa_ctx->info.samples/QOA_FRAME_LEN) frame = qoa_ctx->info.samples/QOA_FRAME_LEN;
qoa_ctx->sample_position = frame*QOA_FRAME_LEN;
qoa_ctx->sample_data_len = 0;
qoa_ctx->sample_data_pos = 0;
unsigned int offset = qoa_ctx->first_frame_pos + frame*qoa_max_frame_size(&qoa_ctx->info);
if (qoa_ctx->file) fseek(qoa_ctx->file, offset, SEEK_SET);
else qoa_ctx->file_data_offset = offset;
}

5584
shared/external/stb_vorbis.c vendored Normal file
View file

File diff suppressed because it is too large Load diff

0
firmware/library/json.hpp → shared/json.hpp
View file

0
story-editor/src/miniz.c → shared/miniz.c
View file

0
story-editor/src/miniz.h → shared/miniz.h
View file

0
story-editor/src/platform_folders.cpp → shared/platform_folders.cpp
View file

0
story-editor/src/platform_folders.h → shared/platform_folders.h
View file

1400
shared/qoixx.hpp Normal file
View file

File diff suppressed because it is too large Load diff

2797
shared/raudio.c Normal file
View file

File diff suppressed because it is too large Load diff

222
shared/raudio.h Normal file
View file

@ -0,0 +1,222 @@
/**********************************************************************************************
*
* raudio v1.1 - A simple and easy-to-use audio library based on miniaudio
*
* FEATURES:
* - Manage audio device (init/close)
* - Manage raw audio context
* - Manage mixing channels
* - Load and unload audio files
* - Format wave data (sample rate, size, channels)
* - Play/Stop/Pause/Resume loaded audio
*
* DEPENDENCIES:
* miniaudio.h - Audio device management lib (https://github.com/mackron/miniaudio)
* stb_vorbis.h - Ogg audio files loading (http://www.nothings.org/stb_vorbis/)
* dr_wav.h - WAV audio files loading (http://github.com/mackron/dr_libs)
* dr_mp3.h - MP3 audio file loading (https://github.com/mackron/dr_libs)
* dr_flac.h - FLAC audio file loading (https://github.com/mackron/dr_libs)
* jar_xm.h - XM module file loading
* jar_mod.h - MOD audio file loading
*
* CONTRIBUTORS:
* David Reid (github: @mackron) (Nov. 2017):
* - Complete port to miniaudio library
*
* Joshua Reisenauer (github: @kd7tck) (2015):
* - XM audio module support (jar_xm)
* - MOD audio module support (jar_mod)
* - Mixing channels support
* - Raw audio context support
*
*
* LICENSE: zlib/libpng
*
* Copyright (c) 2013-2025 Ramon Santamaria (@raysan5)
*
* This software is provided "as-is", without any express or implied warranty. In no event
* will the authors be held liable for any damages arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose, including commercial
* applications, and to alter it and redistribute it freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not claim that you
* wrote the original software. If you use this software in a product, an acknowledgment
* in the product documentation would be appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be misrepresented
* as being the original software.
*
* 3. This notice may not be removed or altered from any source distribution.
*
**********************************************************************************************/
#ifndef RAUDIO_H
#define RAUDIO_H
//----------------------------------------------------------------------------------
// Defines and Macros
//----------------------------------------------------------------------------------
// In case this file is included, we are using raudio in standalone mode
#ifndef RAUDIO_STANDALONE
#define RAUDIO_STANDALONE
#endif // RAUDIO_STANDALONE
// Allow custom memory allocators
#ifndef RL_MALLOC
#define RL_MALLOC(sz) malloc(sz)
#endif
#ifndef RL_CALLOC
#define RL_CALLOC(n,sz) calloc(n,sz)
#endif
#ifndef RL_FREE
#define RL_FREE(p) free(p)
#endif
//----------------------------------------------------------------------------------
// Types and Structures Definition
//----------------------------------------------------------------------------------
#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800)
#include <stdbool.h>
#elif !defined(__cplusplus) && !defined(bool)
typedef enum bool { false = 0, true = !false } bool;
#define RL_BOOL_TYPE
#endif
typedef void (*AudioCallback)(void *bufferData, unsigned int frames);
// Wave, audio wave data
typedef struct Wave {
unsigned int frameCount; // Total number of frames (considering channels)
unsigned int sampleRate; // Frequency (samples per second)
unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
unsigned int channels; // Number of channels (1-mono, 2-stereo, ...)
void *data; // Buffer data pointer
} Wave;
// Opaque structs declaration
typedef struct rAudioBuffer rAudioBuffer;
typedef struct rAudioProcessor rAudioProcessor;
// AudioStream, custom audio stream
typedef struct AudioStream {
rAudioBuffer *buffer; // Pointer to internal data used by the audio system
rAudioProcessor *processor; // Pointer to internal data processor, useful for audio effects
unsigned int sampleRate; // Frequency (samples per second)
unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
unsigned int channels; // Number of channels (1-mono, 2-stereo, ...)
} AudioStream;
// Sound
typedef struct Sound {
AudioStream stream; // Audio stream
unsigned int frameCount; // Total number of frames (considering channels)
} Sound;
// Music, audio stream, anything longer than ~10 seconds should be streamed
typedef struct Music {
AudioStream stream; // Audio stream
unsigned int frameCount; // Total number of frames (considering channels)
bool looping; // Music looping enable
int ctxType; // Type of music context (audio filetype)
void *ctxData; // Audio context data, depends on type
} Music;
//----------------------------------------------------------------------------------
// Global Variables Definition
//----------------------------------------------------------------------------------
//...
//----------------------------------------------------------------------------------
// Module Functions Declaration
//----------------------------------------------------------------------------------
#ifdef __cplusplus
extern "C" { // Prevents name mangling of functions
#endif
// Audio device management functions
void InitAudioDevice(void); // Initialize audio device and context
void CloseAudioDevice(void); // Close the audio device and context
bool IsAudioDeviceReady(void); // Check if audio device has been initialized successfully
void SetMasterVolume(float volume); // Set master volume (listener)
float GetMasterVolume(void); // Get master volume (listener)
// Wave/Sound loading/unloading functions
Wave LoadWave(const char *fileName); // Load wave data from file
Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. ".wav"
bool IsWaveReady(Wave wave); // Checks if wave data is ready
Sound LoadSound(const char *fileName); // Load sound from file
Sound LoadSoundFromWave(Wave wave); // Load sound from wave data
Sound LoadSoundAlias(Sound source); // Create a new sound that shares the same sample data as the source sound, does not own the sound data
bool IsSoundReady(Sound sound); // Checks if a sound is ready
void UpdateSound(Sound sound, const void *data, int frameCount);// Update sound buffer with new data
void UnloadWave(Wave wave); // Unload wave data
void UnloadSound(Sound sound); // Unload sound
void UnloadSoundAlias(Sound alias); // Unload a sound alias (does not deallocate sample data)
bool ExportWave(Wave wave, const char *fileName); // Export wave data to file, returns true on success
bool ExportWaveAsCode(Wave wave, const char *fileName); // Export wave sample data to code (.h), returns true on success
// Wave/Sound management functions
void PlaySound(Sound sound); // Play a sound
void StopSound(Sound sound); // Stop playing a sound
void PauseSound(Sound sound); // Pause a sound
void ResumeSound(Sound sound); // Resume a paused sound
bool IsSoundPlaying(Sound sound); // Check if a sound is currently playing
void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level)
void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level)
void SetSoundPan(Sound sound, float pan); // Set pan for a sound (0.0 to 1.0, 0.5=center)
Wave WaveCopy(Wave wave); // Copy a wave to a new wave
void WaveCrop(Wave *wave, int initSample, int finalSample); // Crop a wave to defined samples range
void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format
float *LoadWaveSamples(Wave wave); // Load samples data from wave as a floats array
void UnloadWaveSamples(float *samples); // Unload samples data loaded with LoadWaveSamples()
// Music management functions
Music LoadMusicStream(const char *fileName); // Load music stream from file
Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char* data, int dataSize); // Load music stream from data
bool IsMusicReady(Music music); // Checks if a music stream is ready
void UnloadMusicStream(Music music); // Unload music stream
void PlayMusicStream(Music music); // Start music playing
bool IsMusicStreamPlaying(Music music); // Check if music is playing
void UpdateMusicStream(Music music); // Updates buffers for music streaming
void StopMusicStream(Music music); // Stop music playing
void PauseMusicStream(Music music); // Pause music playing
void ResumeMusicStream(Music music); // Resume playing paused music
void SeekMusicStream(Music music, float position); // Seek music to a position (in seconds)
void SetMusicVolume(Music music, float volume); // Set volume for music (1.0 is max level)
void SetMusicPitch(Music music, float pitch); // Set pitch for a music (1.0 is base level)
void SetMusicPan(Music music, float pan); // Set pan for a music (0.0 to 1.0, 0.5=center)
float GetMusicTimeLength(Music music); // Get music time length (in seconds)
float GetMusicTimePlayed(Music music); // Get current music time played (in seconds)
// AudioStream management functions
AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Load audio stream (to stream raw audio pcm data)
bool IsAudioStreamReady(AudioStream stream); // Checks if an audio stream is ready
void UnloadAudioStream(AudioStream stream); // Unload audio stream and free memory
void UpdateAudioStream(AudioStream stream, const void *data, int samplesCount); // Update audio stream buffers with data
bool IsAudioStreamProcessed(AudioStream stream); // Check if any audio stream buffers requires refill
void PlayAudioStream(AudioStream stream); // Play audio stream
void PauseAudioStream(AudioStream stream); // Pause audio stream
void ResumeAudioStream(AudioStream stream); // Resume audio stream
bool IsAudioStreamPlaying(AudioStream stream); // Check if audio stream is playing
void StopAudioStream(AudioStream stream); // Stop audio stream
void SetAudioStreamVolume(AudioStream stream, float volume); // Set volume for audio stream (1.0 is max level)
void SetAudioStreamPitch(AudioStream stream, float pitch); // Set pitch for audio stream (1.0 is base level)
void SetAudioStreamPan(AudioStream strean, float pan); // Set pan for audio stream (0.0 to 1.0, 0.5=center)
void SetAudioStreamBufferSizeDefault(int size); // Default size for new audio streams
void SetAudioStreamCallback(AudioStream stream, AudioCallback callback); // Audio thread callback to request new data
void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Attach audio stream processor to stream
void DetachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Detach audio stream processor from stream
void AttachAudioMixedProcessor(AudioCallback processor); // Attach audio stream processor to the entire audio pipeline
void DetachAudioMixedProcessor(AudioCallback processor); // Detach audio stream processor from the entire audio pipeline
#ifdef __cplusplus
}
#endif
#endif // RAUDIO_H

0
story-editor/src/zip.cpp → shared/zip.cpp
View file

0
story-editor/src/zip.h → shared/zip.h
View file

20
story-editor/00_prepare_outdir.sh Executable file
View file

@ -0,0 +1,20 @@
#!/bin/bash
# Nom de l'exécutable à analyser (à remplacer par le votre)
executable="build-linux/story-editor"
# Commande ldd et stockage de la sortie dans une variable
ldd_output=$(ldd "$executable" | awk '/ => / { print $1 }')
echo $ldd_output
# repertoire_courant=$(pwd)
# # Récupère les noms des bibliothèques en filtrant sur le répertoire courant
# bibliotheques_courant=$(ldd "$executable" | awk -v dir="$repertoire_courant" '/ => / && $3 ~ "^"dir"/" { print $3 }')
# # Affiche les résultats
# echo "Bibliothèques dans le répertoire courant :"
# echo "$bibliotheques_courant"

1
story-editor/01_linux_create_docker_image.sh Executable file
View file

@ -0,0 +1 @@
docker buildx build -t cpp-dev-linux -f Dockerfile.linux . --no-cache --load

3
story-editor/02_linux_docker_launch_build.sh Executable file
View file

@ -0,0 +1,3 @@
docker run -v $(pwd)/..:/workspace cpp-dev-linux /bin/bash -c "cd /workspace/story-editor && ./build_linux.sh"

3
story-editor/03_linux_docker_launch_package.sh Executable file
View file

@ -0,0 +1,3 @@
docker run --privileged -v $(pwd)/..:/workspace cpp-dev-linux /bin/bash -c "cd /workspace/story-editor && ./build_appimage.sh"

302
story-editor/CMakeLists.txt
View file

@ -21,81 +21,11 @@ endif()
find_package(OpenGL REQUIRED)
# set(OPENSSL_ROOT_DIR /libs/openssl)
# find_package(OpenSSL REQUIRED)
set(IMGUI_VERSION 1.91.6)
include(FetchContent)
include(cmake/CPM.cmake)
# =========================================================================================================================
# MBedTLS
# =========================================================================================================================
CPMAddPackage(
NAME mbedtls
GITHUB_REPOSITORY Mbed-TLS/mbedtls
VERSION 3.6.2
OPTIONS
"USE_STATIC_MBEDTLS_LIBRARY ON"
"ENABLE_PROGRAMS OFF"
"ENABLE_TESTING OFF"
)
include_directories(${mbedtls_INCLUDE_DIR})
# set(MBEDTLS_STATIC_LIBRARY ON)
# =========================================================================================================================
# CibetWeb
# =========================================================================================================================
CPMAddPackage(
NAME civetweb
GITHUB_REPOSITORY civetweb/civetweb
VERSION 1.16
OPTIONS
"CIVETWEB_BUILD_TESTING OFF"
"CIVETWEB_ENABLE_SERVER_EXECUTABLE OFF"
"CIVETWEB_ENABLE_CXX ON"
"CIVETWEB_ENABLE_WEBSOCKETS ON"
"CIVETWEB_ENABLE_ASAN OFF"
)
find_package(civetweb REQUIRED)
include_directories(${civetweb_SOURCE_DIR}/include)
# =========================================================================================================================
# CURL
# =========================================================================================================================
# Définit les options de cURL pour utiliser mBedTLS
set(CURL_USE_OPENSSL OFF CACHE BOOL "Disable OpenSSL." FORCE)
set(CURL_USE_MBEDTLS ON CACHE BOOL "Use MBED TLS." FORCE)
set(CURL_USE_LIBSSH2 OFF CACHE BOOL "Disable SSH." FORCE)
set(MBEDTLS_INCLUDE_DIRS ${mbedtls_SOURCE_DIR}/include)
set(MBEDTLS_LIBRARY ${mbedtls_BINARY_DIR}/libmbedtls.a)
set(MBEDX509_LIBRARY ${mbedtls_BINARY_DIR}/libmbedx509.a)
set(MBEDCRYPTO_LIBRARY ${mbedtls_BINARY_DIR}/libmbedcrypto.a)
# Télécharge et configure cURL
FetchContent_Declare(
curl
GIT_REPOSITORY https://github.com/curl/curl.git
GIT_TAG curl-8_7_1
GIT_SHALLOW TRUE
GIT_PROGRESS TRUE
)
set(BUILD_CURL_EXE FALSE)
set(BUILD_STATIC_LIBS TRUE)
FetchContent_MakeAvailable(curl)
# Assurez-vous que votre projet trouve les headers de mBedTLS et cURL
include_directories(${mbedtls_SOURCE_DIR}/include)
include_directories(${curl_SOURCE_DIR}/include)
# Adhere to GNU filesystem layout conventions
include(GNUInstallDirs)
# =========================================================================================================================
@ -114,70 +44,37 @@ add_compile_definitions(CUSTOM_IMGUIFILEDIALOG_CONFIG="${CMAKE_SOURCE_DIR}/src/C
add_compile_definitions(IMGUI_INCLUDE="imgui.h")
add_subdirectory(libs/ImGuiFileDialog)
# =========================================================================================================================
# SDL3
# =========================================================================================================================
FetchContent_Declare(
sdl3
GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
GIT_TAG 78cc5c173404488d80751af226d1eaf67033bcc4 # === preview-3.1.6
GIT_SHALLOW TRUE
GIT_PROGRESS TRUE
)
set(BUILD_SHARED_LIBS TRUE)
set(SDL_STATIC TRUE)
FetchContent_MakeAvailable(sdl3)
include_directories(${sdl3_SOURCE_DIR}/include)
# add_subdirectory(${sdl3_SOURCE_DIR})
# =========================================================================================================================
# SDL3 MIXER
# =========================================================================================================================
CPMAddPackage(
NAME sdl3_mixer
URL https://github.com/libsdl-org/SDL_mixer/archive/d4eba31e4ac23a81fffad02e91b17dcb2449a2cb.tar.gz
add_subdirectory(externals/civetweb EXCLUDE_FROM_ALL)
add_subdirectory(externals/curl EXCLUDE_FROM_ALL)
OPTIONS
"BUILD_SHARED_LIBS TRUE"
"SDL_PULSEAUDIO_SHARED TRUE"
"SDL_PIPEWIRE_SHARED TRUE"
)
# Configure SDL by calling its CMake file.
# we use EXCLUDE_FROM_ALL so that its install targets and configs don't
# pollute upwards into our configuration.
add_subdirectory(externals/SDL EXCLUDE_FROM_ALL)
# FetchContent_Declare(
# sdl3_mixer
# GIT_REPOSITORY https://github.com/libsdl-org/SDL_mixer.git
# GIT_TAG d4eba31e4ac23a81fffad02e91b17dcb2449a2cb
# # GIT_SHALLOW TRUE # Ne pas activer shallow sinon le tag n'est pas trouvé
# # GIT_PROGRESS TRUE
# GIT_SUBMODULES ""
# )
# SDL_mixer (used for playing audio)
set(SDLMIXER_MIDI_NATIVE OFF) # disable formats we don't use to make the build faster and smaller. Also some of these don't work on all platforms so you'll need to do some experimentation.
set(SDLMIXER_GME OFF)
set(SDLMIXER_WAVPACK OFF)
set(SDLMIXER_MOD OFF)
set(SDLMIXER_OPUS OFF)
set(SDLMIXER_VENDORED ON) # tell SDL_mixer to build its own dependencies
add_subdirectory(externals/SDL_mixer EXCLUDE_FROM_ALL)
# set(BUILD_SHARED_LIBS TRUE)
# set(SDL_PULSEAUDIO_SHARED TRUE)
# set(SDL_PIPEWIRE_SHARED TRUE)
# FetchContent_MakeAvailable(sdl3_mixer)
# include_directories(${sdl3_mixer_SOURCE_DIR}/include)
# SDL_image (used for loading various image formats)
set(SDLIMAGE_VENDORED OFF)
set(SDLIMAGE_AVIF OFF) # disable formats we don't use to make the build faster and smaller.
set(SDLIMAGE_BMP ON)
set(SDLIMAGE_JPEG ON)
set(SDLIMAGE_WEBP ON)
add_subdirectory(externals/SDL_image EXCLUDE_FROM_ALL)
# =========================================================================================================================
# SDL3-Image
# =========================================================================================================================
FetchContent_Declare(
sdl_image
GIT_REPOSITORY https://github.com/libsdl-org/SDL_image.git
GIT_TAG bcc97c044266080256ef6ed0d690859677212b2b
GIT_PROGRESS TRUE
# GIT_SHALLOW TRUE # Ne pas activer shallow sinon le tag n'est pas trouvé
)
set(SDL3IMAGE_INSTALL OFF)
set(BUILD_SHARED_LIBS TRUE)
FetchContent_MakeAvailable(sdl_image)
include_directories(${sdl_image_SOURCE_DIR}/include)
# =========================================================================================================================
# Project sources
# =========================================================================================================================
@ -185,28 +82,25 @@ set(SRCS
src/main.cpp
src/window_base.cpp
src/console_window.cpp
src/emulator_window.cpp
src/main_window.cpp
src/library_window.cpp
src/platform_folders.cpp
src/windows/window_base.cpp
src/windows/console_window.cpp
src/windows/emulator_window.cpp
src/windows/main_window.cpp
src/windows/library_window.cpp
src/windows/resources_window.cpp
src/windows/properties_window.cpp
src/windows/debugger_window.cpp
src/windows/cpu_window.cpp
src/windows/variables_window.cpp
src/node_editor/media_node_widget.cpp
src/node_editor/base_node_widget.cpp
src/node_editor/node_editor_window.cpp
src/node_editor/function_node_widget.cpp
src/resources_window.cpp
src/properties_window.cpp
src/cpu_window.cpp
src/node_editor/variable_node_widget.cpp
src/gui.cpp
src/code_editor.cpp
src/media_converter.cpp
src/miniz.c
src/zip.cpp
src/web_server.cpp
src/importers/pack_archive.cpp
@ -226,28 +120,35 @@ set(SRCS
${imgui_SOURCE_DIR}/imgui_tables.cpp
${imgui_SOURCE_DIR}/imgui_draw.cpp
../firmware/chip32/chip32_assembler.cpp
../firmware/chip32/chip32_vm.c
../shared/audio_player.cpp
../shared/stb_vorbis.c
../shared/resource_manager.cpp
../shared/library_manager.cpp
../shared/downloader.cpp
../shared/story_db.cpp
../shared/miniz.c
../shared/zip.cpp
../shared/platform_folders.cpp
../shared/raudio.c
# Core engine files
../core/src/compiler.cpp
../core/src/story_project.cpp
../core/src/story_page.cpp
../core/src/base_node.cpp
../core/src/media_node.cpp
../core/src/function_node.cpp
../core/src/connection.cpp
../core/story-manager/src/compiler.cpp
../core/story-manager/src/story_project.cpp
../core/story-manager/src/story_page.cpp
../core/story-manager/src/base_node.cpp
../core/story-manager/src/media_node.cpp
../core/story-manager/src/compare_node.cpp
../core/story-manager/src/branch_node.cpp
../core/story-manager/src/variable_node.cpp
../core/story-manager/src/function_node.cpp
../core/story-manager/src/connection.cpp
../core/story-manager/lib/sys_lib.cpp
../core/story-manager/lib/resource.cpp
../core/lib/sys_lib.cpp
../core/lib/resource.cpp
../core/chip32/chip32_assembler.cpp
../core/chip32/chip32_vm.c
)
if(WIN32)
@ -271,30 +172,34 @@ endif()
target_include_directories(${STORY_EDITOR_PROJECT} PUBLIC
${imgui_SOURCE_DIR}
${sdl2_SOURCE_DIR}/include
# ${te_SOURCE_DIR}
${imgui_SOURCE_DIR}/backends
libs/ImGuiFileDialog
libs/imgui-node-editor
libs
${curl_INCLUDE_DIR}
${CMAKE_SOURCE_DIR}/src
${CMAKE_SOURCE_DIR}/src/importers
${CMAKE_SOURCE_DIR}/src/node_editor
${CMAKE_SOURCE_DIR}/src/node_engine
src
src/importers
src/node_editor
src/windows
../firmware/library
../firmware/chip32
../core/chip32
../shared
../core/src
../core/lib
../core/interfaces
../core/story-manager/src
../core/story-manager/lib
../core/story-manager/interfaces
)
add_definitions(-DIMGUI_USE_WCHAR32 -DVERSION_MAJOR=${PROJECT_VERSION_MAJOR} -DVERSION_MINOR=${PROJECT_VERSION_MINOR} -DVERSION_PATCH=${PROJECT_VERSION_PATCH})
add_definitions(
-DIMGUI_USE_WCHAR32
-DVERSION_MAJOR=${PROJECT_VERSION_MAJOR}
-DVERSION_MINOR=${PROJECT_VERSION_MINOR}
-DVERSION_PATCH=${PROJECT_VERSION_PATCH}
-DRAUDIO_STANDALONE
-DSUPPORT_MODULE_RAUDIO
)
add_link_options(-static-libgcc -static-libstdc++)
if (APPLE)
@ -318,15 +223,11 @@ set_target_properties(${PROJECT_NAME} PROPERTIES
endif()
# target_compile_definitions(${STORY_EDITOR_PROJECT} PUBLIC cimg_display=0)
# target_compile_definitions(${STORY_EDITOR_PROJECT} PUBLIC "$<$<CONFIG:DEBUG>:DEBUG>")
target_link_directories(${STORY_EDITOR_PROJECT} PUBLIC
${sdl3_BINARY_DIR}
${curl_BINARY_DIR}
${libcurl_BINARY_DIR}
${mbedtls_BINARY_DIR}
# ${CivetWeb_BINARY_DIR}
)
# On est obligé de passer par une variable pour injecter
@ -337,14 +238,11 @@ set(SDL_MIXER_BIN_DIR ${sdl3_mixer_BINARY_DIR})
if(UNIX)
target_link_libraries(${STORY_EDITOR_PROJECT}
SDL3::SDL3
SDL3_image::SDL3_image
SDL3_mixer::SDL3_mixer
libcurl_static
mbedtls
civetweb-cpp
SDL3::SDL3
CURL::libcurl
civetweb::civetweb-cpp
pthread
OpenGL::GL
dl
@ -353,34 +251,33 @@ if(UNIX)
elseif(WIN32)
target_link_libraries(${STORY_EDITOR_PROJECT}
OpenGL::GL
SDL3::SDL3
SDL3_image::SDL3_image
SDL3_mixer::SDL3_mixer
SDL3::SDL3
libcurl_static
ws2_32.lib psapi.lib setupapi.lib cfgmgr32.lib advapi32.lib
)
endif()
# =========================================================================================================================
# CPACK INSTALLER
# =========================================================================================================================
install(TARGETS ${STORY_EDITOR_PROJECT} RUNTIME DESTINATION ".")
set(CMAKE_INSTALL_PREFIX "${CMAKE_SOURCE_DIR}/OUTPUT" CACHE PATH "Directory for sbnw installation" FORCE)
# Personnaliser les options d'installation
set(CPACK_PACKAGE_NAME "Open-Story-Editor")
set(CPACK_DEBIAN_PACKAGE_MAINTAINER "Anthony Rabine")
set(CPACK_PACKAGE_DESCRIPTION "Open Story Teller - Node based editor")
set(CPACK_PACKAGE_VENDOR "D8S")
set(CPACK_PACKAGE_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
set(CPACK_PACKAGE_VERSION_MINOR "${PROJECT_VERSION_MINOR}")
set(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}")
set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE")
# set_target_properties(${STORY_EDITOR_PROJECT}
# PROPERTIES
# LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/$<CONFIG>/lib
# RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/$<CONFIG>/bin
# )
# =========================================================================================================================
# DIRECTORY INSTALLER
# =========================================================================================================================
# install(DIRECTORY "${PROJECT_SOURCE_DIR}/assets/" DESTINATION "assets")
install(DIRECTORY "${PROJECT_SOURCE_DIR}/fonts/" DESTINATION "fonts")
install(DIRECTORY "${PROJECT_SOURCE_DIR}/scripts/" DESTINATION "scripts")
install_files("." FILES "${CMAKE_SOURCE_DIR}/LICENSE")
install_files("." FILES "${CMAKE_SOURCE_DIR}/tools/imgui.ini")
install(FILES "${CMAKE_SOURCE_DIR}/LICENSE" DESTINATION ".")
install(FILES "${CMAKE_SOURCE_DIR}/tools/imgui.ini" DESTINATION "bin")
install(TARGETS ${STORY_EDITOR_PROJECT} BUNDLE DESTINATION bin)
if(WIN32)
install_files("." FILES "${SDL_BIN_DIR}/SDL3.dll")
@ -396,9 +293,13 @@ endif()
if(LINUX)
install_files("." FILES "${SDL_BIN_DIR}/libSDL3.so")
install_files("." FILES "${SDL_IMAGE_BIN_DIR}/libSDL3_image.so")
install_files("." FILES "${SDL_MIXER_BIN_DIR}/libSDL3_mixer.so")
install(DIRECTORY "${SDL_BIN_DIR}/" DESTINATION lib FILES_MATCHING REGEX "libSDL3.so(\\..*)?$")
install(DIRECTORY "${SDL_IMAGE_BIN_DIR}/" DESTINATION lib FILES_MATCHING REGEX "libSDL3_image.so(\\..*)?$")
install(DIRECTORY "${SDL_MIXER_BIN_DIR}/" DESTINATION lib FILES_MATCHING REGEX "libSDL3_mixer.so(\\..*)?$")
# install_files("." FILES "${SDL_BIN_DIR}/libSDL3.so")
# install_files("." FILES "${SDL_IMAGE_BIN_DIR}/libSDL3_image.so")
# install_files("." FILES "${SDL_MIXER_BIN_DIR}/libSDL3_mixer.so")
endif()
if (APPLE)
@ -407,4 +308,3 @@ if (APPLE)
install_files("." FILES "${SDL_BIN_DIR}/libSDL2-2.0.0.dylib")
endif()
include(CPack)

4
story-editor/CMakePresets.json
View file

@ -1,5 +1,5 @@
{
"version": 10,
"version": 3,
"cmakeMinimumRequired": {
"major": 3,
"minor": 23,
@ -13,7 +13,7 @@
"generator": "Ninja",
"binaryDir": "${sourceDir}/build",
"environment": {
"CPM_SOURCE_CACHE": "$env{HOME}/.cache/CPM"
}
},
{

49
story-editor/Dockerfile.linux Normal file
View file

@ -0,0 +1,49 @@
# Utiliser une image de base Alpine Linux
FROM ubuntu:24.04
# Installer les dépendances nécessaires
# DEBIAN_FRONTEND=noninteractive permet d'éviter une interaction lors de la config de tzdata
RUN apt update && DEBIAN_FRONTEND=noninteractive apt install -y --no-install-recommends \
build-essential \
flatpak \
flatpak-builder \
file \
wget \
imagemagick \
cmake \
git \
zlib1g-dev \
mesa-common-dev \
libgl1-mesa-dev \
libgles2-mesa-dev \
libxcursor-dev \
libxrandr-dev \
libxinerama-dev \
libxi-dev \
libasound2-dev \
libpulse-dev \
libaudio-dev \
libjack-dev \
libsndio-dev \
libx11-dev \
libxext-dev \
libxfixes-dev \
libxss-dev \
libxkbcommon-dev \
libudev-dev \
fcitx-libs-dev \
libpipewire-0.3-dev \
libwayland-dev \
libdecor-0-dev \
liburing-dev \
libdrm-dev \
libgbm-dev \
libegl1-mesa-dev \
libdbus-1-dev \
libibus-1.0-dev
RUN mkdir /workspace
# Commande par défaut (modifiable dans le script Bash)
CMD ["/bin/bash"]

0
story-editor/Dockerfile → story-editor/Dockerfile.mingw64
View file

BIN
story-editor/OpenStoryEditor-x86_64.AppImage Executable file
View file

Binary file not shown.

BIN
story-editor/appimagetool-x86_64.AppImage Executable file
View file

Binary file not shown.

67
story-editor/build_appimage.sh Executable file
View file

@ -0,0 +1,67 @@
#!/bin/bash
# Variables
APP_NAME="OpenStoryEditor"
APP_DIR="AppDir"
APP_EXE="story-editor"
BUILD_DIR="build-linux"
APPIMAGE_TOOL="appimagetool-x86_64.AppImage"
APPIMAGE_URL="https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage"
# Vérification des dépendances
if ! command -v cmake &> /dev/null; then
echo "Erreur : cmake n'est pas installé. Installez-le avant de continuer."
exit 1
fi
if ! command -v wget &> /dev/null; then
echo "Erreur : wget n'est pas installé. Installez-le avant de continuer."
exit 1
fi
# Étape 1 : Préparer l'AppDir
echo "Préparation de l'AppDir..."
rm -rf "${APP_DIR}"
mkdir -p "${APP_DIR}/usr/bin"
mkdir -p "${APP_DIR}/usr/share/applications"
mkdir -p "${APP_DIR}/usr/share/icons/hicolor/256x256/apps"
# Copier les fichiers nécessaires
cp "${BUILD_DIR}/${APP_EXE}" "${APP_DIR}/usr/bin/"
cat > "${APP_DIR}/${APP_NAME}.desktop" <<EOL
[Desktop Entry]
Type=Application
Name=${APP_NAME}
Exec=${APP_EXE}
Icon=${APP_NAME}
Terminal=false
Categories=Utility;
EOL
cat > "${APP_DIR}/AppRun" <<EOL
#!/bin/bash
HERE="$(dirname "$(readlink -f "${0}")")"
export PATH="$HERE/usr/bin:$PATH"
export LD_LIBRARY_PATH="$HERE/usr/lib:$LD_LIBRARY_PATH"
exec "$HERE/usr/bin/${APP_EXE}" "$@"
EOL
chmod +x ${APP_DIR}/AppRun
# Ajouter une icône (optionnel, remplacer par une vraie icône si disponible)
cp story-editor-logo-256x256.png "${APP_DIR}/usr/share/icons/hicolor/256x256/apps/${APP_NAME}.png"
cp story-editor-logo-256x256.png "${APP_DIR}/${APP_NAME}.png"
cp "${APP_DIR}/${APP_NAME}.desktop" "${APP_DIR}/usr/share/applications/${APP_NAME}.desktop"
# Étape 2 : Télécharger l'outil AppImage
if [ ! -f "${APPIMAGE_TOOL}" ]; then
echo "Téléchargement de l'outil AppImageTool..."
wget "${APPIMAGE_URL}" -O "${APPIMAGE_TOOL}"
chmod +x "${APPIMAGE_TOOL}"
fi
# Étape 3 : Générer l'AppImage
echo "Génération de l'AppImage..."
ARCH=x86_64 ./"${APPIMAGE_TOOL}" "${APP_DIR}" || { echo "Erreur : échec de la création de l'AppImage."; exit 1; }
echo "AppImage générée avec succès : ${APP_NAME}-x86_64.AppImage"

95
story-editor/build_flatpak.sh Executable file
View file

@ -0,0 +1,95 @@
#!/bin/bash
# Variables
APP_NAME="OpenStoryEditor"
APP_ID="eu.d8s.OpenStoryEditor"
VERSION="1.0.0"
ICON_NAME="stoty-editor-logo-256x256.png"
BUILD_DIR="build" # Répertoire où se trouve l'exécutable généré
FLATPAK_DIR="flatpak_build"
FLATPAK_MANIFEST="${FLATPAK_DIR}/${APP_ID}.yaml"
# Vérifier les prérequis
if ! command -v flatpak-builder &> /dev/null; then
echo "Erreur : flatpak-builder n'est pas installé. Installez-le avant de continuer."
exit 1
fi
if [ ! -f "${BUILD_DIR}/${APP_NAME}" ]; then
echo "Erreur : L'exécutable '${BUILD_DIR}/${APP_NAME}' est introuvable."
exit 1
fi
if [ ! -f "${ICON_NAME}" ]; then
echo "Erreur : L'icône '${ICON_NAME}' est introuvable. Placez une icône PNG de 256x256 pixels à la racine."
exit 1
fi
# Préparation du répertoire Flatpak
echo "Création du répertoire Flatpak..."
rm -rf "${FLATPAK_DIR}"
mkdir -p "${FLATPAK_DIR}"
# Génération du fichier manifeste YAML
echo "Création du fichier manifeste Flatpak (${FLATPAK_MANIFEST})..."
cat > "${FLATPAK_MANIFEST}" <<EOL
app-id: ${APP_ID}
runtime: org.freedesktop.Platform
runtime-version: "23.08"
sdk: org.freedesktop.Sdk
command: ${APP_NAME}
finish-args:
- --share=network
- --share=ipc
- --device=dri
- --socket=x11
- --socket=wayland
- --filesystem=home
modules:
- name: ${APP_NAME}
buildsystem: simple
build-commands:
- install -Dm755 story-editor /app/bin/story-editor
- install -Dm644 story-editor.desktop /app/share/applications/story-editor.desktop
- install -Dm644 ${ICON_NAME} /app/share/icons/hicolor/256x256/apps/${APP_ID}.png
sources:
- type: dir
path: ../${BUILD_DIR}
EOL
# Création du fichier .desktop
echo "Création du fichier .desktop..."
cat > "${BUILD_DIR}/${APP_NAME}.desktop" <<EOL
[Desktop Entry]
Type=Application
Name=${APP_NAME}
Exec=${APP_NAME}
Icon=${APP_ID}
Terminal=false
Categories=Utility;
EOL
# Construction du Flatpak
echo "Construction du Flatpak..."
flatpak-builder --force-clean \
"${FLATPAK_DIR}/build-dir" \
"${FLATPAK_MANIFEST}"
if [ $? -ne 0 ]; then
echo "Erreur : Échec de la construction du Flatpak."
exit 1
fi
# Exportation du Flatpak en un fichier .flatpak
echo "Exportation du Flatpak..."
flatpak build-bundle "${FLATPAK_DIR}/build-dir" \
"${FLATPAK_DIR}/${APP_NAME}-${VERSION}.flatpak" \
"${APP_ID}" "${VERSION}"
if [ $? -eq 0 ]; then
echo "Flatpak généré avec succès : ${FLATPAK_DIR}/${APP_NAME}-${VERSION}.flatpak"
else
echo "Erreur : Échec de l'exportation du Flatpak."
exit 1
fi

6
story-editor/build_linux.sh Executable file
View file

@ -0,0 +1,6 @@
mkdir -p /workspace/story-editor/build-linux
cd /workspace/story-editor/build-linux
git config --global http.sslverify false
cmake -DCMAKE_BUILD_TYPE=Release ..
make
cpack

1285
story-editor/cmake/CPM.cmake
View file

File diff suppressed because it is too large Load diff

2
story-editor/create_docker_image_win.sh
View file

@ -1 +1 @@
docker build -t cpp-dev . --load
docker build -t cpp-dev -f Dockerfile.mingw64 --load

1
story-editor/externals/SDL vendored Submodule

@ -0,0 +1 @@
Subproject commit 11dbff246f9015bb79a8f5c761b5b7099a9b579b

1
story-editor/externals/SDL_image vendored Submodule

@ -0,0 +1 @@
Subproject commit 0e9b6b675e804f0a03f9d3ae6e871471f9505d3c

1
story-editor/externals/SDL_mixer vendored Submodule

@ -0,0 +1 @@
Subproject commit af6a29df4e14c6ce72608b3ccd49cf35e1014255

1
story-editor/externals/civetweb vendored Submodule

@ -0,0 +1 @@
Subproject commit 7f95a2632ef651402c15c39b72c4620382dd82bf

1
story-editor/externals/curl vendored Submodule

@ -0,0 +1 @@
Subproject commit 34c1c653fc475efb828658f900979596905c688e

121
story-editor/imgui.ini
View file

@ -4,60 +4,60 @@ Size=1220,694
Collapsed=0
[Window][Debug##Default]
Pos=260,575
Pos=260,280
Size=32,42
Collapsed=0
[Window][Library Manager]
Pos=552,26
Size=728,827
Pos=630,346
Size=650,374
Collapsed=0
DockId=0x00000003,3
DockId=0x0000000B,0
[Window][Console]
Pos=60,855
Size=1220,289
Pos=60,460
Size=568,260
Collapsed=0
DockId=0x00000006,0
DockId=0x00000009,0
[Window][Emulator]
Pos=552,26
Size=728,827
Pos=630,26
Size=453,318
Collapsed=0
DockId=0x00000003,2
DockId=0x00000003,0
[Window][Code editor]
Pos=466,290
Size=814,331
Collapsed=0
DockId=0x00000004,0
DockId=0x00000001,0
[Window][Resources]
Pos=552,26
Size=728,827
Pos=630,346
Size=650,374
Collapsed=0
DockId=0x00000003,0
DockId=0x0000000B,1
[Window][Properties]
Pos=552,26
Size=728,827
Pos=630,26
Size=453,318
Collapsed=0
DockId=0x00000003,1
[Window][Node editor]
Pos=60,26
Size=490,827
Size=568,432
Collapsed=0
DockId=0x00000002,0
DockId=0x00000008,0
[Window][QuitConfirm]
Pos=479,524
Pos=479,312
Size=321,96
Collapsed=0
[Window][ToolBar]
Pos=0,26
Size=60,1118
Size=60,694
Collapsed=0
[Window][ProjectPropertiesPopup]
@ -86,10 +86,10 @@ Size=951,564
Collapsed=0
[Window][CPU]
Pos=552,26
Size=728,827
Pos=60,460
Size=568,260
Collapsed=0
DockId=0x00000003,4
DockId=0x00000009,1
[Window][Choose File##ChooseFileDlgKey]
Pos=122,114
@ -97,20 +97,20 @@ Size=1020,496
Collapsed=0
[Window][TOOLBAR]
Pos=73,64
Pos=85,72
Size=79,42
Collapsed=0
[Window][WindowOverViewport_11111111]
Pos=60,26
Size=1220,1118
Size=1220,694
Collapsed=0
[Window][Code viewer]
Pos=552,26
Size=728,827
Pos=1085,26
Size=195,318
Collapsed=0
DockId=0x00000003,5
DockId=0x00000006,0
[Window][Import story##ImportStoryDlgKey]
Pos=256,33
@ -122,6 +122,23 @@ Pos=216,85
Size=874,542
Collapsed=0
[Window][Choose a binary story##SetSourceScriptDlgKey]
Pos=189,66
Size=879,517
Collapsed=0
[Window][RAM view]
Pos=60,460
Size=568,260
Collapsed=0
DockId=0x00000009,2
[Window][Variables]
Pos=60,460
Size=568,260
Collapsed=0
DockId=0x00000009,3
[Table][0x54B1A511,5]
RefScale=20
Column 0 Width=197 Sort=0v
@ -192,7 +209,7 @@ Column 2 Width=124
[Table][0x7728942D,5]
RefScale=20
Column 0 Width=207 Sort=0v
Column 0 Width=249 Sort=0v
Column 1 Width=119
Column 2 Width=104
Column 3 Width=108
@ -262,12 +279,42 @@ Column 0 Sort=0v
RefScale=20
Column 0 Sort=0v
[Docking][Data]
DockSpace ID=0x08BD597D Window=0x1BBC0F80 Pos=60,26 Size=1220,1118 Split=Y
DockNode ID=0x00000005 Parent=0x08BD597D SizeRef=1220,403 Split=X
DockNode ID=0x00000002 Parent=0x00000005 SizeRef=490,694 CentralNode=1 Selected=0xBB79A587
DockNode ID=0x00000001 Parent=0x00000005 SizeRef=728,694 Split=Y Selected=0x63869CAF
DockNode ID=0x00000003 Parent=0x00000001 SizeRef=543,294 Selected=0x52EB28B5
DockNode ID=0x00000004 Parent=0x00000001 SizeRef=543,372 Selected=0x7563A968
DockNode ID=0x00000006 Parent=0x08BD597D SizeRef=1220,289 Selected=0xEA83D666
[Table][0xFD320A1F,3]
RefScale=20
Column 0 Width=4 Sort=0v
Column 1 Width=4
Column 2 Width=4
[Table][0x965BCEFA,4]
RefScale=20
Column 0 Sort=0v
[Table][0xB3490CB0,4]
RefScale=20
Column 0 Sort=0v
[Table][0x63137D12,4]
RefScale=20
Column 0 Sort=0v
[Table][0x1A9CDA45,4]
RefScale=20
Column 0 Sort=0v
[Table][0xCEE1704D,4]
RefScale=20
Column 0 Sort=0v
[Docking][Data]
DockSpace ID=0x08BD597D Window=0x1BBC0F80 Pos=60,26 Size=1220,694 Split=X
DockNode ID=0x00000004 Parent=0x08BD597D SizeRef=568,694 Split=Y Selected=0xBB79A587
DockNode ID=0x00000008 Parent=0x00000004 SizeRef=607,432 Selected=0xBB79A587
DockNode ID=0x00000009 Parent=0x00000004 SizeRef=607,260 Selected=0x6DE9B20C
DockNode ID=0x00000005 Parent=0x08BD597D SizeRef=769,694 Split=X
DockNode ID=0x00000002 Parent=0x00000005 SizeRef=316,694 Split=Y Selected=0xBB79A587
DockNode ID=0x0000000A Parent=0x00000002 SizeRef=306,462 Split=X Selected=0x8C72BEA8
DockNode ID=0x00000003 Parent=0x0000000A SizeRef=453,363 CentralNode=1 Selected=0x8C72BEA8
DockNode ID=0x00000006 Parent=0x0000000A SizeRef=195,363 Selected=0x52EB28B5
DockNode ID=0x0000000B Parent=0x00000002 SizeRef=306,374 Selected=0x63869CAF
DockNode ID=0x00000001 Parent=0x00000005 SizeRef=902,694 Selected=0x63869CAF

0
story-editor/src/IconsFontAwesome5_c.h → story-editor/libs/IconsFontAwesome5_c.h
View file

0
story-editor/src/IconsMaterialDesignIcons.h → story-editor/libs/IconsMaterialDesignIcons.h
View file

4
story-editor/libs/ImGuiFileDialog/ImGuiFileDialog.cpp
View file

@ -3994,7 +3994,9 @@ void IGFD::FileDialog::m_DisplayPathPopup(ImVec2 vSize) {
if (ImGui::TableNextColumn()) // file name
{
if (ImGui::Selectable(infos_ptr->fileNameExt.c_str(), &selected, ImGuiSelectableFlags_SpanAllColumns | ImGuiSelectableFlags_SpanAvailWidth)) {
static int f = ImGuiSelectableFlags_SpanAllColumns;
f |= ImGuiSelectableFlags_SpanAvailWidth;
if (ImGui::Selectable(infos_ptr->fileNameExt.c_str(), &selected, f )) {
fdi.SetCurrentPath(fdi.ComposeNewPath(fdi.GetCurrentPopupComposedPath()));
fdi.pathClicked = fdi.SelectDirectory(infos_ptr);
ImGui::CloseCurrentPopup();

8
story-editor/src/imgui_memory_editor.h → story-editor/libs/imgui_memory_editor.h
View file

@ -249,10 +249,10 @@ struct MemoryEditor
if (DataEditingAddr != (size_t)-1)
{
// Move cursor but only apply on next frame so scrolling with be synchronized (because currently we can't change the scrolling while the window is being rendered)
if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_UpArrow)) && (ptrdiff_t)DataEditingAddr >= (ptrdiff_t)Cols) { data_editing_addr_next = DataEditingAddr - Cols; }
else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_DownArrow)) && (ptrdiff_t)DataEditingAddr < (ptrdiff_t)mem_size - Cols) { data_editing_addr_next = DataEditingAddr + Cols; }
else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_LeftArrow)) && (ptrdiff_t)DataEditingAddr > (ptrdiff_t)0) { data_editing_addr_next = DataEditingAddr - 1; }
else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_RightArrow)) && (ptrdiff_t)DataEditingAddr < (ptrdiff_t)mem_size - 1) { data_editing_addr_next = DataEditingAddr + 1; }
if (ImGui::IsKeyPressed(ImGuiKey_UpArrow) && (ptrdiff_t)DataEditingAddr >= (ptrdiff_t)Cols) { data_editing_addr_next = DataEditingAddr - Cols; }
else if (ImGui::IsKeyPressed(ImGuiKey_DownArrow) && (ptrdiff_t)DataEditingAddr < (ptrdiff_t)mem_size - Cols) { data_editing_addr_next = DataEditingAddr + Cols; }
else if (ImGui::IsKeyPressed(ImGuiKey_LeftArrow) && (ptrdiff_t)DataEditingAddr > (ptrdiff_t)0) { data_editing_addr_next = DataEditingAddr - 1; }
else if (ImGui::IsKeyPressed(ImGuiKey_RightArrow) && (ptrdiff_t)DataEditingAddr < (ptrdiff_t)mem_size - 1) { data_editing_addr_next = DataEditingAddr + 1; }
}
// Draw vertical separator

0
story-editor/src/stb_image.h → story-editor/libs/stb_image.h
View file

36
story-editor/scripts/test_compiler.chip32 Normal file
View file

@ -0,0 +1,36 @@
; jump over the data, to our entry label
jump .entry
$imageBird DC8 "example.bmp", 8 ; data
$someConstant DC32 12456789
; DSxx to declare a variable in RAM, followed by the number of elements
$RamData1 DV32 1 ; one 32-bit integer
$RamData2 DV32 1 ; one 32-bit integer
$MyArray DV8 10 ; array of 10 bytes
; label definition
.entry: ;; comment here should work
; We create a stupid loop just for RAM variable testing
; Fill the second ram data with pattern, to be sure that there is no memory corrumptions
lcons r0, 0xFFFFFFFF
lcons r2, $RamData2
store @r2, r0, 4 ; save R0 in RAM
lcons r0, 4 ; prepare loop: 4 iterations
lcons r2, $RamData1 ; save in R2 a ram address
store @r2, r0, 4 ; save R0 in RAM
lcons r1, 1
.loop:
load r0, @r2, 4 ; load this variable
sub r0, r1
store @r2, r0, 4 ; save R0 in RAM
skipz r0 ; skip loop if R0 == 0
jump .loop
mov r0, r2 ; copy R2 into R0 (blank space between , and R2)
mov R0,R2 ; copy R2 into R0 (NO blank space between , and R2)
halt

140
story-editor/scripts/test_media.chip32 Normal file
View file

@ -0,0 +1,140 @@
jump .nodeEntry920e33a5-99c2-429c-9214-3776f169051d
$cover.png DC8 "cover.png", 8
$quelle_destination.mp3 DC8 "quelle_destination.mp3", 8
$mediaChoice920e33a5-99c2-429c-9214-3776f169051d DC32, 2, .nodeEntryea561fb0-994b-4777-80f3-58860eda97d6, .nodeEntry45fb3875-38aa-4683-abba-06868c8e109c
$saturne.png DC8 "saturne.png", 8
$saturne.mp3 DC8 "saturne.mp3", 8
$mediaChoice45fb3875-38aa-4683-abba-06868c8e109c DC32, 1, .nodeEntry42abccda-d683-409d-aed9-7727df3d6974
$mars.png DC8 "mars.png", 8
$mars.mp3 DC8 "mars.mp3", 8
$mediaChoiceea561fb0-994b-4777-80f3-58860eda97d6 DC32, 1, .nodeEntryca6a2e13-f4f0-4d1e-a64c-11acacfb97c0
$sature_story.mp3 DC8 "sature_story.mp3", 8
$mediaChoice42abccda-d683-409d-aed9-7727df3d6974 DC32, 0,
$mars_story.mp3 DC8 "mars_story.mp3", 8
$mediaChoiceca6a2e13-f4f0-4d1e-a64c-11acacfb97c0 DC32, 0,
; ---------------------------- Default node Type: Choice
.nodeEntry920e33a5-99c2-429c-9214-3776f169051d:
lcons r0, $cover.png
lcons r1, $quelle_destination.mp3
syscall 1
lcons r0, 0b10000000000
syscall 2
lcons r0, $mediaChoice920e33a5-99c2-429c-9214-3776f169051d
jump .media ; no return possible, so a jump is enough
; ---------------------------- Default node Type: Transition
.nodeEntry45fb3875-38aa-4683-abba-06868c8e109c:
lcons r0, $saturne.png
lcons r1, $saturne.mp3
syscall 1
lcons r0, .nodeEntry42abccda-d683-409d-aed9-7727df3d6974
ret
; ---------------------------- Default node Type: Transition
.nodeEntryea561fb0-994b-4777-80f3-58860eda97d6:
lcons r0, $mars.png
lcons r1, $mars.mp3
syscall 1
lcons r0, .nodeEntryca6a2e13-f4f0-4d1e-a64c-11acacfb97c0
ret
; ---------------------------- Default node Type: End
.nodeEntry42abccda-d683-409d-aed9-7727df3d6974:
lcons r0, 0
lcons r1, $sature_story.mp3
syscall 1
ret
; ---------------------------- Default node Type: End
.nodeEntryca6a2e13-f4f0-4d1e-a64c-11acacfb97c0:
lcons r0, 0
lcons r1, $mars_story.mp3
syscall 1
ret
; Generic media choice manager
.media:
; Les adresses des différents medias sont dans la stack
; Arguments:
; r0: address d'une structure de type "media choice"
; Local:
; t0: current media address
; t1: increment 4
; t3: address of the first element in the choice array
; t4: address of the last element in the choice array
; t5: where to jump when OK button is pressed
mov t3, r0 ; copie de R0 pour travailler dessus
mov t2, r0 ; sauvegarde de R0
load r0, @t3, 4 ; Le premier élément est le nombre de choix possibles, ex: r0 = 12
lcons t1, 4
mul r0, t1 ; on calcule l'offset: r0 = nb_elements * 4 = 48
mov t4, t3 ; t4 = t3
add t4, r0 ; t4 pointe maintenant sur le dernier élément de la structure
add t3, t1 ; t3 pointe maintenant sur le premier élément
mov t0, t3 ; on commence sur le premier élément
.media_loop:
; --------- We call a media transition node
load r0, @t0, 4 ; Get the address located at memory T0
call r0 ; call subroutine
; Return argument in R0: the address of the node to call whe OK is pressed
mov t5, r0 ; save it
; wait for event
lcons r0, 0b100111 ; mask for OK, previous and next buttons, home button
syscall 2
; Event is stored in R0
; ----- Test if event is OK button
lcons r1, 1 ; mask for OK button
and r1, r0 ; r1 = r1 AND r0
skipz r1 ; not OK, skip jump
jump .media_wait_event
; test previous event
lcons r1, 2 ; mask for previous button
and r1, r0 ; r1 = r1 AND r0
skipz r1 ; not OK, skip jump
jump .media_previous
lcons r1, 0b100000 ; mask for home button
and r1, r0 ; r1 = r1 AND r0
skipz r1 ; not Home, skip jump
jump .media_exit
; all other events mean: next node
eq r0, t0, t4 ; t4 est le dernier élément
skipz r0 ; zéro, on peut incrémenter l'adresse
jump .media_set_first
add t0, t1 ; t0 += 4
jump .media_loop
.media_set_first: ; on reboucle sur le premier élément de la structure
mov t0, t3
jump .media_loop
.media_previous:
eq r0, t0, t3 ; on teste si on est au premier élément
skipz r0 ; zéro, on peut décrémenter l'adresse
jump .media_set_last
sub t0, t1 ; t0 += 4
jump .media_loop
.media_set_last: ; on reboucle sur le dernier élément de la structure
mov t0, t4
jump .media_loop
.media_wait_event:
call t5 ; jump to the node
lcons r0, 0b10000100001 ; mask for end of audio, Ok, and home buttons
syscall 2 ; wait for event (OK, home or end of audio), return to choice loop
jump .media_loop
.media_exit:
lcons r0, 1 ; Home button pressed, send signal to exit story
syscall 3 ; exit story, we should never return from this call
halt ; just in case

355
story-editor/src/graph.cpp
View file

@ -1,355 +0,0 @@
#include <iostream>
#include <queue>
#include "graph.h"
using namespace std;
Graph::Graph(int newMaxSize)
: mInvalid()
{
maxSize = newMaxSize;
// vertexList = new Vertex [maxSize];
}
Graph::Graph(const Graph& other)
{
*this = other;
}
Graph& Graph::operator=(const Graph& other)
{
if (this == &other)
{
return *this;
}
if (!empty())
{
vertexList.clear();
}
maxSize = other.maxSize;
vertexList.assign(other.vertexList.begin(), other.vertexList.end());
return *this;
}
Graph::~Graph()
{
// delete[] vertexList;
vertexList.clear();
}
bool Graph::addVertex(const string& id)
{
if (full())
{
return false;
}
Vertex newVertex;
newVertex.setId(id);
vertexList.push_back(newVertex);
return true;
}
void Graph::insertEdge(const string& v1, const string& v2, int wt)
{
std::list<Vertex>::iterator it_v1 = vertexList.end();
std::list<Vertex>::iterator it_v2 = vertexList.end();
for (auto it = vertexList.begin(); it != vertexList.end(); ++it)
{
if (it->getId() == v1)
{
it_v1 = it;
}
if (it->getId() == v2)
{
it_v2 = it;
}
}
if ((it_v1 != vertexList.end()) && (it_v2 != vertexList.end()))
{
if (wt == -1)
{
wt = it_v1->first_edge_gap();
}
it_v1->edges.push_back(make_pair(wt, *it_v2));
}
else
{
std::cout << "Cannot create edge, one vertex is not found" << std::endl;
}
}
Graph::Vertex Graph::first() const
{
if (vertexList.size() > 0) {
return vertexList.front();
} else {
return Vertex();
}
}
Graph::Vertex Graph::getVertex(const string &v) const
{
for (auto it = vertexList.begin(); it != vertexList.end(); ++it)
{
if (it->getId() == v)
{
return *it;
}
}
return mInvalid;
}
Graph::Vertex Graph::getPreviousVertex(const string &id)
{
for (auto it = vertexList.begin(); it != vertexList.end(); ++it)
{
if (it->edges.size() > 0)
{
Vertex v = it->edges.front().second;
if (v.getId() == id)
{
return *it;
}
}
}
return mInvalid;
}
Graph::Vertex Graph::getNextVertex(const std::string &id) const
{
for (auto it = vertexList.begin(); it != vertexList.end(); ++it)
{
if ((it->getId() == id))
{
if (it->edges.size() > 0)
{
return it->edges.front().second;
}
}
}
return mInvalid;
}
void Graph::Vertex::removeEdge(const std::string &id)
{
edges.remove_if([id](const vPair &n){ return (n.second.getId() == id); });
}
bool Graph::removeVertex(const string& v)
{
std::list<Vertex>::iterator it_v = vertexList.end();
// On cherche le vertex
for (auto it = vertexList.begin(); it != vertexList.end(); ++it)
{
if (it->getId() == v)
{
it_v = it;
}
}
// vertex non trouvé
if (it_v == vertexList.end())
{
return false;
}
std::cout << "RM: " << it_v->getId()<< std::endl;
vertexList.erase(it_v);
// On supprime toutes les références à ce vertex dans les autres edges
// == On supprime les relations éventuelles
for (auto it = vertexList.begin(); it != vertexList.end(); ++it)
{
it->removeEdge(v);
}
return true;
}
bool Graph::removeEdge(const string& v1, const string& v2)
{
bool success = false;
for (auto it = vertexList.begin(); it != vertexList.end(); ++it)
{
if (it->getId() == v1)
{
success = true;
it->removeEdge(v2);
break;
}
}
return success;
}
bool Graph::clearExtraEdges(const std::string &v1)
{
bool success = false;
for (auto it = vertexList.begin(); it != vertexList.end(); ++it)
{
if (it->getId() == v1)
{
success = true;
it->edges.remove_if([](const Vertex::vPair &n){ return (n.first != 0); });
break;
}
}
return success;
}
void Graph::clear()
{
vertexList.clear();
}
bool Graph::empty() const
{
return (vertexList.size() == 0);
}
bool Graph::full() const
{
return (vertexList.size() == maxSize);
}
void Graph::showGraph() const
{
if (empty())
{
cout << "Empty Graph" << endl;
return;
}
cout << "Vertex and their adjacency list:" << endl;
for (auto it = vertexList.begin(); it != vertexList.end(); ++it)
{
cout << '\t' << it->getId();
for (const auto &j : it->edges)
{
cout << " --> [" << j.second.getId()
<< ", " << j.first << ']';
}
cout << endl;
}
}
/*
void Graph::bfs(const string& src, const string& dest) const
{
int src_idx = getIndex(src),
dest_idx = getIndex(dest);
if (src_idx == -1 ||
dest_idx == -1)
return;
queue<int> q;
vector<bool> visited(size, false);
q.push(src_idx);
visited[src_idx] = true;
while (!q.empty())
{
int u = q.front();
q.pop();
cout << ' ' << vertexList[u].getId() << endl;
if (u == dest_idx)
return;
for (auto i : vertexList[u].edges)
{
int v = getIndex(i.second.getId());
if (!visited[v])
{
visited[v] = true;
q.push(v);
}
}
}
}
void Graph::shortestPaths(const string& src) const
{
typedef pair<int,int> vtx;
priority_queue<vtx,
vector<vtx>,
greater<vtx> > pq;
vector<int> dist(size, INF);
int src_idx = getIndex(src);
if (src_idx == -1) return;
dist[src_idx] = 0;
pq.push(make_pair(0, src_idx));
while (!pq.empty())
{
int u = pq.top().second;
pq.pop();
for (auto i : vertexList[u].edges)
{
int v = getIndex(i.second.getId());
int wt = i.first;
if (dist[v] > dist[u] + wt)
{
dist[v] = dist[u] + wt;
pq.push(make_pair(dist[v], v));
}
}
}
for (int i = 0; i < size; i++)
{
cout << '\t' << vertexList[i].getId();
if (dist[i] == INF)
cout << '\t' << '-' << endl;
else
cout << '\t' << dist[i] << endl;
}
cout << endl;
}
int Graph::getIndex(const string& v) const
{
for (int i = 0; i < size; i++)
if (v == vertexList[i].getId())
return i;
return -1;
}
*/

134
story-editor/src/graph.h
View file

@ -1,134 +0,0 @@
#ifndef GRAPH_H
#define GRAPH_H
#include <utility>
#include <climits>
#include <string>
#include <vector>
#include <list>
#include <algorithm>
class Graph
{
static const int DEFAULT_MAX_SIZE = 1000;
static const int INF = INT_MAX;
public:
class Vertex
{
public:
Vertex()
{
mValid = false;
}
~Vertex()
{
}
int first_edge_gap()
{
std::vector<int> vec;
for (auto &p : edges)
{
vec.push_back(p.first);
}
// Handle the special case of an empty vector. Return 1.
if( vec.empty() )
{
return 1;
}
// Sort the vector
std::sort( vec.begin(), vec.end() );
// Find the first adjacent pair that differ by more than 1.
auto i = std::adjacent_find( vec.begin(), vec.end(), [](int l, int r){return l+1<r;} );
// Handle the special case of no gaps. Return the last value + 1.
if ( i == vec.end() )
{
--i;
}
return 1 + *i;
}
bool isValid() const { return mValid; }
void setId(const std::string& newId)
{ mId = newId; mValid = true; }
std::string getId() const
{ return mId; }
void removeEdge(const std::string &id);
// poids / vertex
typedef std::pair<int, Vertex> vPair;
std::list<vPair> edges;
Vertex& operator=(const Vertex& other)
{
mId = other.mId;
edges = other.edges;
mValid = other.mValid;
return *this;
}
private:
std::string mId{"invalid"};
bool mValid{false};
};
Graph(int newMaxSize = DEFAULT_MAX_SIZE);
Graph(const Graph& other);
Graph& operator=(const Graph& other);
~Graph();
typedef std::list<Vertex>::iterator Iter;
std::list<Vertex>::iterator begin() { return vertexList.begin(); }
std::list<Vertex>::const_iterator begin() const { return vertexList.begin(); }
std::list<Vertex>::iterator end() { return vertexList.end(); }
std::list<Vertex>::const_iterator end() const { return vertexList.end(); }
bool addVertex(const std::string& id);
// If defaut weight is -1, then auto attribute the weight
void insertEdge(const std::string& v1, const std::string& v2, int wt = -1);
Vertex first() const;
Vertex getVertex(const std::string& id) const;
Vertex getPreviousVertex(const std::string &id);
Vertex getNextVertex(const std::string &id) const;
bool searchVertex(const std::string& v, Vertex& returnVertex) const;
// bool searchEdge(const std::string& v1, const std::string& v2,
// int& wt) const;
bool removeVertex(const std::string& v1);
bool removeEdge(const std::string& v1, const std::string& v2);
bool clearExtraEdges(const std::string& v1);
void clear();
bool empty() const;
bool full() const;
void showGraph() const;
// void bfs(const std::string& src,
// const std::string& dest) const;
// void shortestPaths(const std::string& src) const;
private:
int getIndex(const std::string& v) const;
Vertex mInvalid;
std::list<Vertex> vertexList;
int maxSize;
};
#endif // GRAPH_H

84
story-editor/src/media_converter.cpp
View file

@ -17,30 +17,60 @@
#define DR_MP3_IMPLEMENTATION
#include "dr_mp3.h"
#define QOI_IMPLEMENTATION
#include "qoi.h"
#include <filesystem>
#include <vector>
#include <cstddef>
#include <fstream>
#include <iostream>
#include <cstdlib>
#include <memory>
#include <variant>
#include <string>
#include <string_view>
#include "qoixx.hpp"
struct QoiDescription {
unsigned int width;
unsigned int height;
unsigned char channels;
unsigned char colorspace;
void * pixels;
};
static inline void save_file(const std::filesystem::path& path, const std::vector<std::byte>& bytes){
std::ofstream ofs{path, std::ios::binary};
ofs.write(reinterpret_cast<const char*>(bytes.data()), bytes.size());
}
using image = std::variant<QoiDescription, std::pair<std::vector<std::byte>, qoixx::qoi::desc>>;
static int qoi_encode_and_write(const char *filename, const void *data, const qoi_desc *desc) {
FILE *f = fopen(filename, "wb");
int size;
void *encoded;
template<typename... Fs>
struct overloaded : Fs...{
using Fs::operator()...;
};
template<typename... Fs> overloaded(Fs...) -> overloaded<Fs...>;
if (!f) {
return 0;
}
encoded = qoi_encode(data, desc, &size);
if (!encoded) {
fclose(f);
return 0;
}
fwrite(encoded, 1, size, f);
fclose(f);
free(encoded);
return size;
static inline void write_qoi(const std::filesystem::path& file_path, const image& image){
auto [ptr, size, desc] = std::visit(overloaded(
[](const QoiDescription& image){
return std::make_tuple(
reinterpret_cast<const std::byte*>(image.pixels),
static_cast<std::size_t>(image.width) * image.height * image.channels,
qoixx::qoi::desc{
.width = static_cast<std::uint32_t>(image.width),
.height = static_cast<std::uint32_t>(image.height),
.channels = static_cast<std::uint8_t>(image.channels),
.colorspace = qoixx::qoi::colorspace::srgb
}
);
},
[](const std::pair<std::vector<std::byte>, qoixx::qoi::desc>& image){
return std::make_tuple(image.first.data(), image.first.size(), image.second);
}
), image);
const auto encoded = qoixx::qoi::encode<std::vector<std::byte>>(ptr, size, desc);
save_file(file_path, encoded);
}
MediaConverter::MediaConverter()
@ -69,26 +99,28 @@ int MediaConverter::ImageToQoi(const std::string &inputFileName, const std::stri
if (pixels != NULL)
{
qoi_desc desc;
QoiDescription desc;
desc.channels = channels;
desc.colorspace = QOI_SRGB;
desc.colorspace = 0; // #define QOI_SRGB 0
desc.width = w;
desc.height = h;
desc.pixels = pixels;
int encoded = qoi_encode_and_write(outputFileName.c_str(), pixels, &desc);
write_qoi(outputFileName.c_str(), desc);
free(pixels);
/*
if (!encoded)
{
return cErrorCannotWriteOrEncodeOutputFile;
}
*/
}
else
{
return cErrorCannotDecodeInputFile;
}
return cSuccess;
}

18
story-editor/src/node_editor/media_node_widget.cpp
View file

@ -25,24 +25,6 @@ void MediaNodeWidget::Draw()
{
BaseNodeWidget::FrameStart();
/*
static ImGuiTableFlags flags = ImGuiTableFlags_Borders |
ImGuiTableFlags_NoHostExtendX | ImGuiTableFlags_SizingFixedFit;
ImGui::PushStyleVar(ImGuiStyleVar_CellPadding, ImVec2(10.0f, 10.0f));
if (ImGui::BeginTable("table1", 1, flags))
{
ImGui::TableNextRow();
ImU32 bg_color = ImGui::GetColorU32(ImVec4(0.3f, 0.3f, 0.7f, 1.0f));
ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, bg_color);
ImGui::TableSetColumnIndex(0);
ImGui::TextUnformatted("Media node");
ImGui::EndTable();
}
ImGui::PopStyleVar();
*/
const char * text = "Media node";
// Obtenir la position courante du curseur
ImVec2 pos = ImGui::GetCursorScreenPos();

2
story-editor/src/node_editor/node_editor_window.cpp
View file

@ -11,6 +11,7 @@
#include "media_node_widget.h"
#include "function_node_widget.h"
#include "variable_node_widget.h"
#include "gui.h"
#include "uuid.h"
@ -29,6 +30,7 @@ NodeEditorWindow::NodeEditorWindow(IStoryManager &manager)
registerNode<MediaNodeWidget>("media-node");
registerNode<FunctionNodeWidget>("function-node");
registerNode<VariableNodeWidget>("variable-node");
}
NodeEditorWindow::~NodeEditorWindow()

66
story-editor/src/node_editor/variable_node_widget.cpp Normal file
View file

@ -0,0 +1,66 @@
#include <sstream>
#include "variable_node_widget.h"
namespace ed = ax::NodeEditor;
#include "IconsMaterialDesignIcons.h"
#include "story_project.h"
#include "uuid.h"
VariableNodeWidget::VariableNodeWidget(IStoryManager &manager, std::shared_ptr<BaseNode> node)
: BaseNodeWidget(manager, node)
, m_manager(manager)
{
// Create defaut one input and one output
//AddInput();
AddOutputs(1);
SetOutPinName(0, "");
}
void VariableNodeWidget::Initialize()
{
BaseNodeWidget::Initialize();
}
void VariableNodeWidget::DrawProperties()
{
ImGui::AlignTextToFramePadding();
static ImGuiComboFlags flags = 0;
if (ImGui::BeginCombo("Variables list", m_selectedVariable.c_str(), flags))
{
int i = 0;
m_manager.ScanVariable([&i, this] (Variable &var) {
// ImGui::PushID(static_cast<int>(i)); // Assure l'unicité des widgets
const bool is_selected = (m_selectedIndex == i);
if (ImGui::Selectable(var.name.c_str(), is_selected))
{
m_selectedIndex = i;
m_selectedVariable = var.name;
}
// Set the initial focus when opening the combo (scrolling + keyboard navigation focus)
if (is_selected)
ImGui::SetItemDefaultFocus();
});
ImGui::EndCombo();
}
}
void VariableNodeWidget::Draw()
{
BaseNodeWidget::FrameStart();
ImGui::TextUnformatted(m_selectedVariable.c_str());
DrawPins();
BaseNodeWidget::FrameEnd();
}

31
story-editor/src/node_editor/variable_node_widget.h Normal file
View file

@ -0,0 +1,31 @@
#pragma once
#include <vector>
#include <map>
#include <mutex>
#include <set>
#include "base_node_widget.h"
#include "i_story_manager.h"
#include "i_story_project.h"
#include "gui.h"
#include "variable_node.h"
#include <imgui_node_editor.h>
#include "media_node.h"
class VariableNodeWidget : public BaseNodeWidget
{
public:
VariableNodeWidget(IStoryManager &manager, std::shared_ptr<BaseNode> node);
void Draw() override;
virtual void DrawProperties() override;
virtual void Initialize() override;
private:
IStoryManager &m_manager;
std::shared_ptr<VariableNode> m_variableNode;
int m_selectedIndex{-1};
std::string m_selectedVariable;
};

138
story-editor/src/ost_wrapper.cpp
View file

@ -1,138 +0,0 @@
#include <iostream>
#include <memory>
#include "imgui.h"
#include "IconsFontAwesome5.h"
#include "SDL.h"
#include "imgui-knobs.h"
#include "ost_common.h"
#include "ost_wrapper.h"
#include "picture.h"
static SDL_Texture *display_texture{nullptr};
// OST stubs
extern "C" void system_putc(char ch)
{
std::cout << ch;
std::flush(std::cout);
}
static color_t image_buffer[320][240];
extern "C" void ost_display_draw_h_line(uint16_t y, uint8_t *pixels, uint8_t *palette)
{
color_t color;
for(uint16_t i = 0; i < 320; i++)
{
uint8_t val = pixels[i];
if (val > 15)
{
val = 0;
}
const uint8_t *palettePtr = &palette[val * 4];
color.r = palettePtr[0];
color.g = palettePtr[1];
color.b = palettePtr[2];
image_buffer[i][y] = color;
}
}
static void ost_impl_show_image(SDL_Renderer *renderer, const char *fileName)
{
decompress(fileName);
display_texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_TARGET, 320, 240);
// Switch the renderer to the texture
SDL_SetRenderTarget(renderer, display_texture);
SDL_RenderClear(renderer);
for (uint16_t y = 0; y < 240; y++)
{
for(uint16_t x = 0; x < 320; x++)
{
SDL_SetRenderDrawColor(renderer, image_buffer[x][y].r, image_buffer[x][y].g, image_buffer[x][y].b, 255);
SDL_RenderDrawPoint(renderer, x, 239 - y);
}
}
SDL_RenderPresent(renderer);
// Switch back to main screen renderer
SDL_SetRenderTarget(renderer, NULL);
}
// Emulated hardware
void draw_ost_device(SDL_Renderer *renderer, double deltaTime)
{
static int load = 0;
if (load == 0)
{
load = 1;
ost_impl_show_image(renderer, "assets/images/example.bmp");
}
ImGui::Begin("OST device");
ImDrawList* draw_list = ImGui::GetWindowDrawList();
if (ImGui::Button("OK"))
{
std::cout << "OK button clicked" << std::endl;
}
ImGui::SameLine();
if (ImGui::Button("Home"))
{
std::cout << "Choose RIGHT" << std::endl;
}
ImGui::SameLine();
if (ImGui::Button("Pause"))
{
std::cout << "Choose RIGHT" << std::endl;
}
ImGui::SameLine();
if (ImGui::Button("Rotate LEFT"))
{
std::cout << "Choose LEFT" << std::endl;
}
ImGui::SameLine();
if (ImGui::Button("Rotate RIGHT"))
{
std::cout << "Choose RIGHT" << std::endl;
}
ImGui::NewLine();
// Contenu de l'écran
if (display_texture != nullptr)
{
ImGui::Image(display_texture, ImVec2((float)320, (float)240));
}
else
{
ImVec2 canvas_pos = ImGui::GetCursorScreenPos(); // ImDrawList API uses screen coordinates!
ImVec2 canvas_size(320, 240);
// Rectangle vide
draw_list->AddRectFilledMultiColor(canvas_pos, ImVec2(canvas_pos.x + canvas_size.x, canvas_pos.y + canvas_size.y), IM_COL32(50, 50, 50, 255), IM_COL32(50, 50, 60, 255), IM_COL32(60, 60, 70, 255), IM_COL32(50, 50, 60, 255));
// contour blanc
draw_list->AddRect(canvas_pos, ImVec2(canvas_pos.x + canvas_size.x, canvas_pos.y + canvas_size.y), IM_COL32(255, 255, 255, 255));
}
ImGui::End();
}

18
story-editor/src/ost_wrapper.h
View file

@ -1,18 +0,0 @@
#ifndef OST_WRAPPER_H
#define OST_WRAPPER_H
#ifdef __cplusplus
extern "C"
{
#endif
#include <SDL.h>
void draw_ost_device(SDL_Renderer *renderer, double deltaTime);
#ifdef __cplusplus
}
#endif
#endif // OST_WRAPPER_H

0
story-editor/src/console_window.cpp → story-editor/src/windows/console_window.cpp
View file

0
story-editor/src/console_window.h → story-editor/src/windows/console_window.h
View file

0
story-editor/src/cpu_window.cpp → story-editor/src/windows/cpu_window.cpp
View file

0
story-editor/src/cpu_window.h → story-editor/src/windows/cpu_window.h
View file

29
story-editor/src/code_editor.cpp → story-editor/src/windows/debugger_window.cpp
View file

@ -1,4 +1,4 @@
#include "code_editor.h"
#include "debugger_window.h"
#include "IconsMaterialDesignIcons.h"
#include <fstream>
#include <memory>
@ -9,7 +9,7 @@
#include "imgui.h"
void CodeEditor::TextViewDraw()
void DebuggerWindow::TextViewDraw()
{
const ImVec2 childSize = ImVec2(0, 0);
// Début de la scrollview (Child)
@ -33,11 +33,14 @@ void CodeEditor::TextViewDraw()
std::string line;
std::istringstream is(m_text);
if ((m_focusOnLine != -1) && (m_focusOnLine != m_currentLine))
{
m_currentLine = m_focusOnLine;
// Calcul de la position Y pour centrer la ligne cible
float scrollY = m_currentLine * lineHeight - ImGui::GetWindowHeight() * 0.5f + lineHeight * 0.5f;
// Début de la scrollview
ImGui::SetScrollY(scrollY);
float scrollY = m_currentLine * lineHeight - ImGui::GetWindowHeight() * 0.5f + lineHeight * 0.5f;
// Début de la scrollview
ImGui::SetScrollY(scrollY);
}
while (std::getline(is, line))
{
@ -90,7 +93,7 @@ void CodeEditor::TextViewDraw()
}
CodeEditor::CodeEditor(IStoryManager &project)
DebuggerWindow::DebuggerWindow(IStoryManager &project)
: WindowBase("Code viewer")
, m_storyManager(project)
{
@ -98,7 +101,7 @@ CodeEditor::CodeEditor(IStoryManager &project)
// SetFlags(ImGuiWindowFlags_MenuBar);
}
void CodeEditor::Initialize()
void DebuggerWindow::Initialize()
{
// error markers
@ -112,19 +115,19 @@ void CodeEditor::Initialize()
}
void CodeEditor::ClearErrors()
void DebuggerWindow::ClearErrors()
{
// m_markers.clear();
}
void CodeEditor::AddError(int line, const std::string &text)
void DebuggerWindow::AddError(int line, const std::string &text)
{
// m_markers.insert(std::make_pair(line, text));
// mEditor.SetErrorMarkers(m_markers);
}
void CodeEditor::SetScript(const std::string &txt)
void DebuggerWindow::SetScript(const std::string &txt)
{
m_text = txt;
@ -143,14 +146,14 @@ void CodeEditor::SetScript(const std::string &txt)
// HighlightLine(2);
}
std::string CodeEditor::GetScript() const
std::string DebuggerWindow::GetScript() const
{
// return mEditor.GetText();
return "";
}
void CodeEditor::Draw()
void DebuggerWindow::Draw()
{
WindowBase::BeginDraw();

7
story-editor/src/code_editor.h → story-editor/src/windows/debugger_window.h
View file

@ -5,10 +5,10 @@
#include "i_story_manager.h"
#include <unordered_set>
class CodeEditor : public WindowBase
class DebuggerWindow : public WindowBase
{
public:
CodeEditor(IStoryManager &project);
DebuggerWindow(IStoryManager &project);
virtual void Draw() override;
@ -21,7 +21,7 @@ public:
void HighlightLine(int line)
{
m_currentLine = line;
m_focusOnLine = line;
// mEditor.SetExecutionMarker(line);
// m_highlights[line] = ImVec4(0.5f, 0.5f, 1.0f, 0.5f);
}
@ -31,6 +31,7 @@ private:
std::string m_text;
std::unordered_set<int> m_breakpoints;
// std::map<int, ImVec4> m_highlights;
int m_focusOnLine{-1};
int m_currentLine{-1};
// TextEditor mEditor;
// TextEditor::Breakpoints m_breakPoints;

34
story-editor/src/emulator_window.cpp → story-editor/src/windows/emulator_window.cpp
View file

@ -115,15 +115,29 @@ void EmulatorWindow::Draw()
config.path = ".";
config.countSelectionMax = 1;
config.flags = ImGuiFileDialogFlags_Modal;
ImGuiFileDialog::Instance()->OpenDialog("LoadBinarySoryDlgKey",
ImGuiFileDialog::Instance()->OpenDialog("LoadBinaryStoryDlgKey",
"Choose a binary story",
".c32",
config
);
}
// ---------------- Load Binary story
if (ImGuiFileDialog::Instance()->Display("LoadBinarySoryDlgKey"))
ImGui::SameLine();
if (ImGui::Button("Set script source file (.chip32)"))
{
IGFD::FileDialogConfig config;
config.path = ".";
config.countSelectionMax = 1;
config.flags = ImGuiFileDialogFlags_Modal;
ImGuiFileDialog::Instance()->OpenDialog("SetSourceScriptDlgKey",
"Choose a binary story",
".chip32",
config
);
}
// ---------------- Load Binary story
if (ImGuiFileDialog::Instance()->Display("LoadBinaryStoryDlgKey"))
{
if (ImGuiFileDialog::Instance()->IsOk())
{
@ -137,6 +151,20 @@ void EmulatorWindow::Draw()
ImGuiFileDialog::Instance()->Close();
}
// ---------------- External source file
if (ImGuiFileDialog::Instance()->Display("SetSourceScriptDlgKey"))
{
if (ImGuiFileDialog::Instance()->IsOk())
{
std::string filePathName = ImGuiFileDialog::Instance()->GetFilePathName();
std::string filePath = ImGuiFileDialog::Instance()->GetCurrentPath();
std::string filter = ImGuiFileDialog::Instance()->GetCurrentFilter();
m_story.SetExternalSourceFile(filePathName);
}
// close
ImGuiFileDialog::Instance()->Close();
}
WindowBase::EndDraw();

0
story-editor/src/emulator_window.h → story-editor/src/windows/emulator_window.h
View file

0
story-editor/src/library_window.cpp → story-editor/src/windows/library_window.cpp
View file

0
story-editor/src/library_window.h → story-editor/src/windows/library_window.h
View file

71
story-editor/src/main_window.cpp → story-editor/src/windows/main_window.cpp
View file

@ -20,16 +20,18 @@
#endif
#include "IconsMaterialDesignIcons.h"
#include "ImGuiFileDialog.h"
#include "imgui_memory_editor.h"
MainWindow::MainWindow()
: m_resources(*this)
, m_libraryManager(*this)
, m_emulatorWindow(*this)
, m_codeEditorWindow(*this)
, m_debuggerWindow(*this)
, m_cpuWindow(*this)
, m_resourcesWindow(*this)
, m_nodeEditorWindow(*this)
, m_libraryWindow(*this, m_libraryManager)
, m_variablesWindow(*this)
, m_player(*this)
, m_webServer(m_libraryManager)
{
@ -497,7 +499,7 @@ bool MainWindow::Initialize()
m_player.Initialize(); // Initialize audio after GUI (uses SDL)
// gui.ApplyTheme();
m_codeEditorWindow.Initialize();
m_debuggerWindow.Initialize();
m_emulatorWindow.Initialize();
m_nodeEditorWindow.Initialize();
m_PropertiesWindow.Initialize();
@ -795,9 +797,10 @@ void MainWindow::OpenProject(const std::string &uuid)
m_nodeEditorWindow.Enable();
m_emulatorWindow.Enable();
m_consoleWindow.Enable();
m_codeEditorWindow.Enable();
m_debuggerWindow.Enable();
m_resourcesWindow.Enable();
m_PropertiesWindow.Enable();
m_variablesWindow.Enable();
m_cpuWindow.Enable();
}
else
@ -857,14 +860,15 @@ void MainWindow::CloseProject()
m_nodeEditorWindow.Initialize();
m_emulatorWindow.ClearImage();
m_consoleWindow.ClearLog();
m_codeEditorWindow.ClearErrors();
m_codeEditorWindow.SetScript("");
m_debuggerWindow.ClearErrors();
m_debuggerWindow.SetScript("");
m_nodeEditorWindow.Disable();
m_emulatorWindow.Disable();
m_codeEditorWindow.Disable();
m_debuggerWindow.Disable();
m_resourcesWindow.Disable();
m_PropertiesWindow.Disable();
m_variablesWindow.Disable();
m_cpuWindow.Disable();
RefreshProjectInformation();
@ -942,11 +946,14 @@ void MainWindow::Loop()
{
m_consoleWindow.Draw();
m_emulatorWindow.Draw();
m_codeEditorWindow.Draw();
m_debuggerWindow.Draw();
m_resourcesWindow.Draw();
m_nodeEditorWindow.Draw();
m_variablesWindow.Draw();
m_cpuWindow.Draw();
static MemoryEditor mem_edit_1;
mem_edit_1.DrawWindow("RAM view", m_chip32_ctx.ram.mem, m_chip32_ctx.ram.size);
m_PropertiesWindow.SetSelectedNode(m_nodeEditorWindow.GetSelectedNode());
m_PropertiesWindow.Draw();
@ -1048,10 +1055,18 @@ void MainWindow::LoadBinaryStory(const std::string &filename)
if (sz <= m_chip32_ctx.rom.size)
{
fread(m_chip32_ctx.rom.mem, sz, 1, fp);
m_dbg.run_result = VM_READY;
chip32_initialize(&m_chip32_ctx);
Log("Loaded binary file: " + filename);
size_t sizeRead = fread(m_chip32_ctx.rom.mem, sz, 1, fp);
if (sizeRead == sz)
{
m_dbg.run_result = VM_READY;
chip32_initialize(&m_chip32_ctx);
Log("Loaded binary file: " + filename);
}
else
{
Log("Failed to load binary file", true);
}
}
fclose(fp);
}
@ -1081,11 +1096,29 @@ uint32_t MainWindow::GetRegister(int reg)
return regVal;
}
void MainWindow::ScanVariable(const std::function<void(Variable& element)>& operation)
{
if (m_story)
{
m_story->ScanVariable(operation);
}
}
void MainWindow::AddVariable()
{
m_story->AddVariable();
}
void MainWindow::DeleteVariable(int i)
{
m_story->DeleteVariable(i);
}
void MainWindow::BuildNodes(bool compileonly)
{
if (m_story->GenerateScript(m_currentCode))
{
m_codeEditorWindow.SetScript(m_currentCode);
m_debuggerWindow.SetScript(m_currentCode);
Build(compileonly);
}
}
@ -1104,7 +1137,7 @@ void MainWindow::Build(bool compileonly)
}
Chip32::Assembler::Error err;
m_codeEditorWindow.ClearErrors();
m_debuggerWindow.ClearErrors();
if (m_story->GenerateBinary(m_currentCode, err))
{
m_result.Print();
@ -1126,17 +1159,23 @@ void MainWindow::Build(bool compileonly)
else
{
Log(err.ToString(), true);
m_codeEditorWindow.AddError(err.line, err.message); // show also the error in the code editor
m_debuggerWindow.AddError(err.line, err.message); // show also the error in the code editor
}
}
void MainWindow::BuildCode(bool compileonly)
{
m_currentCode = m_codeEditorWindow.GetScript();
m_currentCode = SysLib::ReadFile(m_externalSourceFileName);
m_debuggerWindow.SetScript(m_currentCode);
Build(compileonly);
}
void MainWindow::SetExternalSourceFile(const std::string &filename)
{
m_externalSourceFileName = filename;
}
void MainWindow::UpdateVmView()
{
@ -1148,7 +1187,7 @@ void MainWindow::UpdateVmView()
if (m_story->GetAssemblyLine(pcVal, m_dbg.line))
{
m_codeEditorWindow.HighlightLine(m_dbg.line);
m_debuggerWindow.HighlightLine(m_dbg.line);
std::cout << "Executing line: " << m_dbg.line << std::endl;
}
else

14
story-editor/src/main_window.h → story-editor/src/windows/main_window.h
View file

@ -6,12 +6,13 @@
#include "gui.h"
#include "console_window.h"
#include "code_editor.h"
#include "debugger_window.h"
#include "emulator_window.h"
#include "resources_window.h"
#include "node_editor_window.h"
#include "properties_window.h"
#include "variables_window.h"
#include "chip32_assembler.h"
#include "chip32_vm.h"
@ -92,6 +93,7 @@ private:
Chip32::Result m_result;
DebugContext m_dbg;
std::string m_currentCode;
std::string m_externalSourceFileName; // path of an external script to be used as compilation input
std::vector<std::string> m_recentProjects;
@ -102,7 +104,7 @@ private:
Gui m_gui;
EmulatorWindow m_emulatorWindow;
ConsoleWindow m_consoleWindow;
CodeEditor m_codeEditorWindow;
DebuggerWindow m_debuggerWindow;
CpuWindow m_cpuWindow;
char m_project_name[256] = "";
@ -115,6 +117,8 @@ private:
LibraryWindow m_libraryWindow;
VariablesWindow m_variablesWindow;
AudioPlayer m_player;
struct VmEvent
@ -143,10 +147,16 @@ private:
virtual void BuildNodes(bool compileonly) override;
virtual void BuildCode(bool compileonly) override;
virtual void SetExternalSourceFile(const std::string &filename) override;
virtual void LoadBinaryStory(const std::string &filename) override;
virtual void ToggleBreakpoint(int line) override;
virtual uint32_t GetRegister(int reg) override;
// Variable
virtual void ScanVariable(const std::function<void(Variable& element)>& operation) override;
virtual void AddVariable() override;
virtual void DeleteVariable(int i);
virtual void Play() override;
virtual void Step() override;
virtual void Run() override;

0
story-editor/src/properties_window.cpp → story-editor/src/windows/properties_window.cpp
View file

0
story-editor/src/properties_window.h → story-editor/src/windows/properties_window.h
View file

0
story-editor/src/resources_window.cpp → story-editor/src/windows/resources_window.cpp
View file

0
story-editor/src/resources_window.h → story-editor/src/windows/resources_window.h
View file

113
story-editor/src/windows/variables_window.cpp Normal file
View file

@ -0,0 +1,113 @@
#include "variables_window.h"
#include "gui.h"
#include "ImGuiFileDialog.h"
#include "IconsMaterialDesignIcons.h"
#include "chip32_vm.h"
#include "variable.h"
VariablesWindow::VariablesWindow(IStoryManager &proj)
: WindowBase("Variables")
, m_story(proj)
{
}
void VariablesWindow::Initialize()
{
}
// Fonction pour convertir un entier en float selon l'échelle
float ScaledToFloat(int64_t value, int scalePower) {
return static_cast<float>(value) * std::pow(10.0f, scalePower);
}
// Fonction pour convertir un float en entier selon l'échelle
int64_t FloatToScaled(float floatValue, int scalePower) {
return static_cast<int64_t>(floatValue / std::pow(10.0f, scalePower));
}
void VariablesWindow::ShowRAMEditor()
{
if (ImGui::Button("Add Variable")) {
// Ajouter une nouvelle variable par défaut
m_story.AddVariable();
}
ImGui::Separator();
int i = 0;
m_story.ScanVariable([&i, this] (Variable &var) {
ImGui::PushID(static_cast<int>(i)); // Assure l'unicité des widgets
if (ImGui::TreeNode((var.name + "###variable").c_str()))
{
// Modifier le nom de la variable
static char buffer[Variable::NameMaxSize];
std::strncpy(buffer, var.name.c_str(), sizeof(buffer));
buffer[sizeof(buffer) - 1] = '\0'; // Assure la terminaison
if (ImGui::InputText("Name", buffer, sizeof(buffer))) {
var.name = buffer;
}
// Choisir le type de la variable
const char* types[] = {"Integer", "String"};
static int selectedType = (var.type == "Integer") ? 0 : 1;
if (ImGui::Combo("Type", &selectedType, types, IM_ARRAYSIZE(types))) {
var.type = types[selectedType];
}
if (var.type == "Integer")
{
// Modifier l'échelle
ImGui::InputInt("Scale Power (10^x)", &var.scalePower);
// Modifier la valeur entière
int intValue = static_cast<int>(var.value);
if (ImGui::InputInt("Integer Value", &intValue)) {
var.value = static_cast<int64_t>(intValue);
}
// Afficher la valeur flottante calculée
float floatValue = ScaledToFloat(var.value, var.scalePower);
ImGui::Text("Float Value: %.6f", floatValue);
}
else
{
std::strncpy(buffer, var.valueText.c_str(), sizeof(buffer));
if (ImGui::InputText("Text value", buffer, sizeof(buffer)))
{
var.valueText = buffer;
}
}
// Bouton pour supprimer la variable
if (ImGui::Button("Delete")) {
m_story.DeleteVariable(i);
ImGui::TreePop();
ImGui::PopID();
}
ImGui::TreePop();
}
ImGui::PopID();
i++;
});
}
void VariablesWindow::Draw()
{
WindowBase::BeginDraw();
ShowRAMEditor();
WindowBase::EndDraw();
}

22
story-editor/src/windows/variables_window.h Normal file
View file

@ -0,0 +1,22 @@
#pragma once
#include "window_base.h"
#include "i_story_manager.h"
#include "gui.h"
class VariablesWindow : public WindowBase
{
public:
VariablesWindow(IStoryManager &proj);
void Initialize();
virtual void Draw() override;
private:
IStoryManager &m_story;
void ShowRAMEditor();
};

0
story-editor/src/window_base.cpp → story-editor/src/windows/window_base.cpp
View file

0
story-editor/src/window_base.h → story-editor/src/windows/window_base.h
View file

BIN
story-editor/story-editor
View file

Binary file not shown.

BIN
story-editor/story-editor-logo-256x256.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 18 KiB

BIN
story-editor/story-editor-logo-512x512.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 42 KiB

Some files were not shown because too many files have changed in this diff Show more