vlktut main.cpp as of 2023-12-15

#include <libxmp-lite/xmp.h>
#define SDL_MAIN_HANDLED
#include <SDL2/SDL.h>
#include <SDL2/SDL_vulkan.h> //why isn't this included inside SDL.h?
#include <glm/glm.hpp>
#include <vulkan/vulkan.h>

#include <iostream>
#include <stdexcept>
#include <cstdlib>

#include <vk/vk_all.hpp>
#include <sfx.hpp>
#include <file.hpp>


class HelloTriangleApplication {
public:
  void run(Uint32 winW = 640, Uint32 winH = 480){
    _initWindow(winW, winH);
    _initVulkan();
    _mainLoop();
    _cleanup();
  }


private:
  SDL_Window* _window = nullptr;
  Uint32 _windowID = 0;

  VkInstance _instance = nullptr;


  void _createInstance(){
    VkApplicationInfo appInfo{};
    appInfo.sType              = VK_STRUCTURE_TYPE_APPLICATION_INFO;
    appInfo.pApplicationName   = "cool triangle";
    appInfo.applicationVersion = VK_MAKE_VERSION(1,0,0);
    appInfo.pEngineName        = "No Engine";
    appInfo.engineVersion      = VK_MAKE_VERSION(1,0,0);
    appInfo.apiVersion         = VK_API_VERSION_1_0;


    bool success;  VkResult result;

    Uint32 extensionsReq_len = 0; //# of required extensions
    success = SDL_Vulkan_GetInstanceExtensions(_window, &extensionsReq_len, nullptr);
    if(!success) throw SDL_GetError();
    std::vector<const char*> extensionsReq(extensionsReq_len);
    success = SDL_Vulkan_GetInstanceExtensions(_window, &extensionsReq_len, extensionsReq.data());
    if(!success) throw SDL_GetError();

    Uint32 extensionsHas_len = 0; //# of available extensions
    result = vkEnumerateInstanceExtensionProperties(nullptr, &extensionsHas_len, nullptr);
    if(result != VK_SUCCESS) throw "vkEnumerateInstanceExtensionProperties() failed";
    std::vector<VkExtensionProperties> extensionsHas(extensionsHas_len);
    result = vkEnumerateInstanceExtensionProperties(nullptr, &extensionsHas_len, extensionsHas.data());
    if(result != VK_SUCCESS) throw "vkEnumerateInstanceExtensionProperties() failed";
/*
    Uint32 extensionsWant_len = 0; //# of desired extensions
    //extensionsWant cannot be larger than extensionsHas
    std::vector<char[VK_MAX_EXTENSION_NAME_SIZE]> extensionsWant(extensionsHas_len);
    for(Uint32 i=0; i<extensionsReq_len; ++i){
      extensionsWant[extensionsWant_len++] = "aaaa";
    }
*/


    SDL_Log("# of required extensions = %u:",extensionsReq_len);
    for(Uint32 i=0; i<extensionsReq_len; ++i){
      SDL_Log("  %u: \"%s\"",i,extensionsReq[i]);
    }

    SDL_Log("\n# of available extensions = %u:",extensionsHas_len);
    for(Uint32 i=0; i<extensionsHas_len; ++i){
      SDL_Log("  %2u: \"%s\" (%u)",i,extensionsHas[i].extensionName,extensionsHas[i].specVersion);
    }


    VkInstanceCreateInfo createInfo{};
    createInfo.sType                   = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
    createInfo.pApplicationInfo        = &appInfo;
    createInfo.enabledLayerCount       = 0; //TBD
    //createInfo.enabledExtensionCount   = extensions_len;
    //createInfo.ppEnabledExtensionNames = extensions.data();

    result = vkCreateInstance(&createInfo, nullptr, &_instance);
    if(result == VK_ERROR_EXTENSION_NOT_PRESENT) throw "vkCreateInstance() = VK_ERROR_EXTENSION_NOT_PRESENT";
    if(result != VK_SUCCESS) throw "vkCreateInstance() failed";
  }


  void _initWindow(Uint32 winW = 640, Uint32 winH = 480){
    _window = SDL_CreateWindow("a cool triangle",
                               SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
                               winW, winH, SDL_WINDOW_VULKAN);
    if(_window == nullptr) throw SDL_GetError();
    _windowID = SDL_GetWindowID(_window);
    if(_windowID == 0) throw SDL_GetError();
  }


  void _initVulkan(){
    _createInstance();
  }


  void _mainLoop(){
    bool running = true;
    SDL_Event event;

    while(running){
      while(SDL_PollEvent(&event) && running){
        switch(event.type){
        case SDL_WINDOWEVENT:
          //the window id isn't checked here, so it could theoretically
           //be another window entirely lol
          if(event.window.event == SDL_WINDOWEVENT_CLOSE) running = false;
        }
      }
      SDL_Delay(16);
    }
  }


  void _cleanup(){
    vkDestroyInstance(_instance, nullptr);
    _instance = nullptr;
    if(_window != nullptr){
      SDL_DestroyWindow(_window);
      _window = nullptr;
    }
  }
};



#define M_2PI (3.1415927f*2)
float get_sin(float hertz = 440, int increment = 1){
  static int index = 0;
  float value = SDL_sinf( ((float)index/44100)*M_2PI*hertz );
  index += increment;
  return value;
}

//(t>>4)*(t>>3)|t>>2
float get_sample(){
  static int _t = 0;
  int t = _t * (8000.0f/44100);

  //Uint8 _value = t*(t&16384?6:5)*(4-(1&t>>8))>>(3&t>>9)|t>>(t&4096?3:4);
  Uint8 _value = t<<2^t>>4^t<<4&t>>8|t<<1&-t>>4;
  float value = _sfx_u8conv(_value);

  ++_t;
  return value;
}


void auxCallback(void* userdata, void* _stream, int size){
  int       len = size/sizeof(float);
  float* stream = (float*)_stream;
  for(int i=0; i<len; ++i){
    //stream[i] = get_sin()*0.25f;
    stream[i] = get_sample()*0.25f;

  }
}




int main(int argc, char** argv){
  if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO)) return -1;
/*
  //wip vulkan stuff; ignore
  HelloTriangleApplication app;
  try {
    app.run();
  } catch(const std::exception& e){
    std::cerr << e.what() << std::endl;
    return EXIT_FAILURE;
  } catch(const char* e){
    std::cout << "error = " << e << std::endl;
    return EXIT_FAILURE;
  }
*/

  try {
    sfx_class sfx(64); //a maximum of 64 tracks that can play simultaneously
    sfx.setAux(auxCallback, nullptr, AUDIO_F32, 1);
    sfx_pcm loop1("dat/UNX - LSDLOOP1.kpm",&sfx); //load sound effect

    sfx.pauseDeviceAndWait(false); //unpause device, and wait for fade-in

    loop1.loopCount = 2; //play 1 + 2 times for a total of 3
    //loop1.play(); //alias for sfx.play(loop1) basically
    SDL_Delay(8000);
    //sfx.waitForTracks(0); //wait for all tracks to stop, with an indefinite timeout

    sfx.pauseDeviceAndWait(true); //pause device, and wait for fade-out

  } catch(const char* e){
    std::cout << "error = " << e << std::endl;
    return EXIT_FAILURE;
  }

  SDL_Quit();
  return EXIT_SUCCESS;
}