Proposal for Enhancements to Boscaceoil-blue

[ghost]

Hello yurisizov,

My name is Ray, and I am excited to contribute to the further development of Boscaceoil-blue. Following up on our previous discussion, here are the key areas we will focus on:

Proposed Contributions:
Addition of .ogg Sound Format Exporter

Objective: Extend audio export options by supporting the OGG format.

Plan: Integrate the OGG exporter into the existing export functionality.

Addition of .mp3 Sound Format Exporter

Objective: Provide users with an option to export audio in MP3 format.

Plan: Implement MP3 export functionality using an external library for encoding.

Replacement of the Current Bootsplash with an Animated Boot Splash

Objective: Enhance user experience with a modern, animated boot splash screen.

Plan: Develop a new animation and integrate it into the startup process.

Refinement of the .gitignore File

Maintain a Clean Repository

Purpose: Exclude unnecessary files from the repository.

Impact: Keeps the repository organized and free of clutter, making it easier to navigate and manage.

Improve Efficiency

Purpose: Optimize the repository by ignoring files that do not need version control, such as temporary files or build artifacts.

Impact: Enhances the performance of version control operations like cloning, fetching, and pushing, as only relevant files are tracked.

Introduction of a contributors.txt File

Objective: Acknowledge all contributors and foster community engagement.

Plan: Create and maintain a contributors.txt file to recognize contributions.

Collaboration and Feedback
I look forward to discussing these proposals further and outlining the steps needed to implement them. Your feedback and suggestions are highly valued. Let's collaborate to make Boscaceoil-blue even better

[YuriSizov]

Hey, thanks for your suggestions! In future, please try to make one discussion per suggestion or at least a group of related suggestions. That'd make it easier to discuss specifics.

Addition of .ogg Sound Format Exporter
Objective: Extend audio export options by supporting the OGG format.
Plan: Integrate the OGG exporter into the existing export functionality.

Addition of .mp3 Sound Format Exporter
Objective: Provide users with an option to export audio in MP3 format.
Plan: Implement MP3 export functionality using an external library for encoding.

These are good to have features, although not terribly critical. As Bosca provides export to WAV, you can use pretty much any external tool to convert it to any target format, starting with ffmpeg. That said, I'd like to have native exports too, to reduce friction for such common tasks.

However, this is not a trivial matter. Such formats as MP3 and OGG are complex and require external libraries to implement. WAV is implemented ad hoc because it's trivial and you just store raw data. These other formats require compression and other configuration options, at which point there is no reason to maintain our own implementation. So a library should be used, likely wrapped into a GDExtension. Or alternatively, a path to an external tool could be configured in Bosca, like the aforementioned ffmpeg, so we just call it directly.

I'm curious, what's your idea for the implementation?

Note: The MP3 feature request is tracked in #29.

Replacement of the Current Bootsplash with an Animated Boot Splash
Objective: Enhance user experience with a modern, animated boot splash screen.
Plan: Develop a new animation and integrate it into the startup process.

I don't think there is a need for that. It's a tool and not a game, and you should be able to jump into it as quickly as possible. We can't avoid having a boot splash while the engine initializes itself, but there is no need to delay the user further with extra animation.

Refinement of the .gitignore File
Maintain a Clean Repository
Purpose: Exclude unnecessary files from the repository.
Impact: Keeps the repository organized and free of clutter, making it easier to navigate and manage.

Improve Efficiency
Purpose: Optimize the repository by ignoring files that do not need version control, such as temporary files or build artifacts.
Impact: Enhances the performance of version control operations like cloning, fetching, and pushing, as only relevant files are tracked.

There are no unnecessary or temporary files in the repository right now. Which ones do you think need to be excluded?

Introduction of a contributors.txt File
Objective: Acknowledge all contributors and foster community engagement.
Plan: Create and maintain a contributors.txt file to recognize contributions.

That's a fine idea. It's not a big issue right now, as there are only like 2 external contributors in the commit log, but at some point it'd be nice to have an accessible list of everyone involved. Terry used to add people to the credits list in the app itself, and I should probably do that as well, especially now that it's a scrollable popup with unlimited space.

[ghost]

I have modified the .gitignore file to ignore import files generated by Godot. I recommend recommitting the files without the .import files.

[YuriSizov]

Hey! As I commented in #54, this would be incorrect. These files are needed for the project to load correctly in the editor, and you cannot work on the project if they are missing. They are also needed for consistent and repeatable builds.

Is this the first time you're working with Godot? If so, no worries, of course! But let's discuss changes before you commit to them if this is an unfamiliar territory to you.

[ghost]

Extremely sorry for that. I usually ignore those files for my projects. I'll keep that in mind.

[ghost]

Hey, I've decided to implement my own library as a Godot addon to support .mp3 and .ogg formats in BoscaCeoil-blue. By creating a Godot addon, we can efficiently integrate the necessary functionalities while managing the complexity.

[YuriSizov]

While I'm intrigued by this idea, I'm also not convinced that this is the right approach for this app. I assume you mean a GDScript addon, which means you want to create your own implementation of relevant codecs. This is really unnecessary, as there are well-tested and better maintained libraries out there that can handle this task.

Audio formats are complex and compressed audio formats are even more complex still. When you create your own implementation, you open doors to many new issues which need to be tested for, caught, and fixed — and you don't really gain anything in return. As an academic exercise this is of course a cool idea, but it's highly impractical.

I believe the right approach would be to make a GDExtension that wraps a library that can convert .wav/raw waveform data to .mp3, .ogg, or any other lossy format. To that end, I don't think there is a better candidate than ffmpeg. It can do everything that Bosca may need here, and if properly used the resulting library would be relatively small (compared to the full size of the prebuilt ffmpeg executable). I looked into it a bit, and don't see any major problems with this approach, since there are even ready-to-use examples for audio decoding and encoding.

So not to dissuade you, but I won't be accepting a custom GDScript addon that attempts to do the same thing that other, better-tested software already does well.

[ghost]

Sorry to disturb you again, but here is the final idea to integrate WAV, MP3, and OGG:

Detailed Guide to Bundling FFmpeg with BoscaCeoil

Step 1: Create a Directory for FFmpeg Binaries

1. Create a Directory for FFmpeg Binaries:

   • In your BoscaCeoil project, create a directory to store the FFmpeg binaries, e.g., res://addons/audio_encoder/bin/.

2. Copy FFmpeg Binaries to Your Project Directory:

   • Copy the extracted FFmpeg binaries into the res://addons/audio_encoder/bin/ directory.

Step 2: Implement GDExtension Code to Use Local FFmpeg Binaries

audio_encoder.h

#ifndef AUDIO_ENCODER_H
#define AUDIO_ENCODER_H

#include <Godot.hpp>
#include <RefCounted.hpp>

using namespace godot;

class AudioEncoder : public RefCounted {
    GDCLASS(AudioEncoder, RefCounted);

protected:
    static void _bind_methods();

public:
    AudioEncoder();
    ~AudioEncoder();

    bool encode_audio(String input_path, String output_path, String output_format, Dictionary options);
    bool is_ffmpeg_installed();
    String get_ffmpeg_path();
};

#endif // AUDIO_ENCODER_H

audio_encoder.cpp

#include "audio_encoder.h"
#include <cstdlib>  // For system() function

using namespace godot;

void AudioEncoder::_bind_methods() {
    ClassDB::bind_method(D_METHOD("encode_audio", "input_path", "output_path", "output_format", "options"), &AudioEncoder::encode_audio);
    ClassDB::bind_method(D_METHOD("is_ffmpeg_installed"), &AudioEncoder::is_ffmpeg_installed);
    ClassDB::bind_method(D_METHOD("get_ffmpeg_path"), &AudioEncoder::get_ffmpeg_path);
}

AudioEncoder::AudioEncoder() {}
AudioEncoder::~AudioEncoder() {}

bool AudioEncoder::is_ffmpeg_installed() {
    String cmd = get_ffmpeg_path() + " -version > /dev/null 2>&1";
    int result = system(cmd.utf8().get_data());
    return result == 0;
}

String AudioEncoder::get_ffmpeg_path() {
#ifdef WINDOWS
    return "res://addons/audio_encoder/bin/ffmpeg.exe";
#elif OSX
    return "res://addons/audio_encoder/bin/ffmpeg";
#elif LINUX
    return "res://addons/audio_encoder/bin/ffmpeg";
#else
    return "ffmpeg";
#endif
}

bool AudioEncoder::encode_audio(String input_path, String output_path, String output_format, Dictionary options) {
    String codec_options = "";

    if (options.has("bitrate")) {
        codec_options += String(" -b:a {0}k").format(Array::make(options["bitrate"]));
    }
    if (options.has("quality")) {
        codec_options += String(" -q:a {0}").format(Array::make(options["quality"]));
    }
    if (options.has("sample_rate")) {
        codec_options += String(" -ar {0}").format(Array::make(options["sample_rate"]));
    }

    // FFmpeg command to encode audio
    String cmd = String("{0} -i {1} {2} {3}.{4}").format(Array::make(get_ffmpeg_path(), input_path, codec_options, output_path, output_format));
    int result = system(cmd.utf8().get_data());
    return result == 0;
}

audio_encoder.gdextension

[configuration]
entry_symbol = "godot_gdnative_init"
dependency = "Gdnative"

[libraries]
windows.64 = "res://addons/audio_encoder/bin/audio_encoder.dll"
osx.64 = "res://addons/audio_encoder/bin/audio_encoder.dylib"
x11.64 = "res://addons/audio_encoder/bin/audio_encoder.so"

Step 3: Compile the GDExtension

Step 4: Integrate and Use the GDExtension in Godot

audio_encoder.gdns

[gd_resource type="NativeScript" load_steps=2 format=2]

[ext_resource path="res://addons/audio_encoder/audio_encoder.gdextension" type="GDNativeLibrary" id=1]

[resource]
resource_name = "AudioEncoder"
class_name = "AudioEncoder"
library = ExtResource(1)

Example Usage

example_usage.gd

extends Node

var _audio_encoder = preload("res://addons/audio_encoder/audio_encoder.gdns").new()

# General function to encode audio
func encode_audio_file(input_path: String, output_path: String, output_format: String, options: Dictionary) -> void:
    if not _audio_encoder.is_ffmpeg_installed():
        print("FFmpeg is not installed. Please install FFmpeg from https://ffmpeg.org/download.html.")
        return
    
    var success = _audio_encoder.encode_audio(input_path, output_path, output_format, options)
    if success:
        print("Audio successfully encoded to", output_format)
    else:
        print("Failed to encode audio to", output_format)

# Example usage for CEOL to MP3
func export_ceol_to_mp3():
    var input_path = "res://path/to/input.ceol"
    var output_path = "res://path/to/output"
    var output_format = "mp3"
    var options = {
        "bitrate": 320,  # Maximum bitrate for MP3
        "sample_rate": 48000  # High sample rate
    }
    
    encode_audio_file(input_path, output_path, output_format, options)

# Example usage for WAV to OGG
func export_wav_to_ogg():
    var input_path = "res://path/to/input.wav"
    var output_path = "res://path/to/output"
    var output_format = "ogg"
    var options = {
        "quality": 10,  # Maximum quality for OGG
        "sample_rate": 48000  # High sample rate
    }
    
    encode_audio_file(input_path, output_path, output_format, options)

# Example usage for CEOL to WAV
func export_ceol_to_wav():
    var input_path = "res://path/to/input.ceol"
    var output_path = "res://path/to/output"
    var output_format = "wav"
    var options = {
        "sample_rate": 48000  # High sample rate
    }
    
    encode_audio_file(input_path, output_path, output_format, options)

Summary

1. Create a Directory for FFmpeg Binaries in your BoscaCeoil project and copy the extracted FFmpeg binaries into it.
2. Implement GDExtension code to reference the local FFmpeg binaries for encoding tasks.
3. Compile the GDExtension.
4. Integrate and use the GDExtension in your Godot project.
5. Use the GDExtension to encode audio files with specified options in MP3, OGG, WAV formats.

[YuriSizov]

Listen, I appreciate your desire to help. But from the look of it you're using ChatGPT or something of that nature and it gives you nonsensical answers. What you've shared here is a mix of GDExtension and GDNative (which only exists in Godot 3). Parts of it taken directly from the example in the engine documentation. And this isn't even a reasonable approach: if we're relying on a pre-built ffmpeg executable, we don't need an extension or a GDNative library. This can be done from GDScript.

But not the point. If you want to help people, using LLMs to generate you a bulk of work that you don't understand yourself is not the way to do it. If I wanted to use an LLM to build this app, I certainly wouldn't need someone else as a proxy. I'd just use it directly. But when you do it and pass it as your own genuine contribution it is simply disrespectful and wastes another person's time. You're doing the opposite of helping.

So I hope you take this close to heart and find a way to get involved in some project with your own skills and knowledge, or at least with a desire to improve your skills and knowledge. But I won't be replying to your suggestions anymore.