RadialLogComponent.cpp

#if defined( _WIN32 )
#pragma warning(disable: 4324) //https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-4-c4324?view=msvc-170
#pragma warning(disable: 4201) //https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-4-c4201?view=msvc-170
#pragma warning(disable: 4310) //https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-3-c4310?view=msvc-170
#pragma warning(disable: 4458) //https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-4-c4458?view=msvc-170
#endif
 
#include "RadialLogComponent.h"
 
#include "EntityStore.h"
 
#include "Components/Core/MeshComponent.h"
#include "Components/Core/MeshRenderComponent.h"
#include "Components/Core/SubMeshRenderComponent.h"
#include "Components/Core/TransformComponent.h"
 
#include "Resources/MaterialManager.h"
#include "Resources/DefaultMaterial.h"
#include "Resources/MeshManager.h"
 
#include "Types.h"
 
using namespace Cogs::Reflection;
 
namespace Cogs::Core
{
  void RadialLogComponent::registerType()
  {
    Field fields[] = {
      Field(Name("positions"), &RadialLogComponent::positions),
      Field(Name("indexes"), &RadialLogComponent::indexes),
      Field(Name("azimuths"), &RadialLogComponent::azimuths),
      Field(Name("inclinations"), &RadialLogComponent::inclinations),
      Field(Name("radiuses"), &RadialLogComponent::radiuses),
      Field(Name("gradient"), &RadialLogComponent::gradient),
      Field(Name("colors"), &RadialLogComponent::colors),
      Field(Name("normalize_range"), &RadialLogComponent::normalize_range),
      Field::create("r_min", &RadialLogComponent::r_min).setRange(0.0f, 1.0f),
      Field::create("r_max", &RadialLogComponent::r_max).setRange(0.0f, 1.0f),
      Field::create("high_side_size", &RadialLogComponent::high_side_size).setRange(0.0f, 1.0f),
      Field(Name("high_side_index"), &RadialLogComponent::high_side_index),
      Field(Name("high_side_color"), &RadialLogComponent::high_side_color),
    };
    Method methods [] = {
      Method(Name("initialize"), &RadialLogComponent::initialize),
      Method(Name("update"), &RadialLogComponent::update),
    };
    TypeDatabase::createType<RadialLogComponent>()
      .setFields(fields)
      .setMethods(methods)
      .setBase<DynamicComponent>();
  }
  RadialLogComponent::RadialLogComponent():
    DynamicComponent()
  {
  }
  void RadialLogComponent::initialize(Context *set_context)
  {
    context = set_context;
    auto material = context->materialManager->getDefaultMaterial();
    instance = context->materialInstanceManager->createMaterialInstance(material);
    instance->setVariant("EnableLighting", false);
    instance->setVariant("VertexColor", true);
    instance->setVariant("LightModel", "BaseColor");
    instance->setVariant("Textured", false);
    instance->setOption("CullMode", "None");
    instance->setVec3Property(DefaultMaterial::EmissiveColor, glm::vec3(0.0));
 
  }
  void RadialLogComponent::update()
  {
    if (!normalize_range && (lr_min == r_min) && (lr_max == r_max)) return;
    // TODO: should be ok with no gradient if there's a texture with the right size
    if (!radiuses || !radiuses.size() || !indexes || !indexes.size() || !gradient || !gradient.size()) return;
 
    lr_min = r_min;
    lr_max = r_max;
    auto entity = getContainer();
 
    if (normalize_range) {
      normalize_range = false;
      float r_a = 999999999.0f;
      float r_b = -999999999.0f;
      for (float tmp : radiuses) {
        if (tmp < 0.0f) continue;
        r_a = glm::min(r_a, tmp);
        r_b = glm::max(r_b, tmp);
      }
      r_min = r_a;
      r_max = r_b;
    }
 
    const size_t sample_count = indexes.size();
    const size_t sectors = radiuses.size() / sample_count;
 
    const size_t indexes_per_sample = (2 * sectors + 2 + 1);
    const size_t vertex_count = sample_count * sectors;
    const size_t max_index_count = sample_count * indexes_per_sample;
 
    // Gen index buffer
    std::vector<unsigned int> indexBuffer(max_index_count);
    uint32_t i = 0;
    for (uint32_t s = 0; s < (uint32_t)(sample_count - 1); s++) {
      for (uint32_t r = 0; r < (uint32_t)sectors; r++) {
        indexBuffer[i++] = (s * (uint32_t)sectors) + r;
        indexBuffer[i++] = ((s + 1) * (uint32_t)sectors) + r;
      }
 
      indexBuffer[i++] = (s * (uint32_t)sectors);
      indexBuffer[i++] = ((s + 1) * (uint32_t)sectors);
      // Degenerate Triangle:
      indexBuffer[i++] = ((s + 1) * (uint32_t)sectors);
    }
 
    // Gen vertex buffer
    MeshComponent* meshComp = entity->getComponent<MeshComponent>();
    auto mesh = context->meshManager->createLocked();
    meshComp->meshHandle = mesh.getHandle();
    auto meshRenderComp = entity->getComponent<MeshRenderComponent>();
    if (meshRenderComp) meshRenderComp->material = instance;
 
    std::vector<glm::vec3> vertexBuffer(vertex_count);
    std::vector<glm::vec4> colorsVector(vertex_count);
    unsigned int idx = 0;
    for (size_t s = 0; s < sample_count; s++) {
 
      const glm::vec3 p = positions[s];
 
      for (size_t r = 0; r < sectors; r++) {
 
        float ra = radiuses[r + s * sectors];
 
        float rad = glm::half_pi<float>() - 2.0f * (float(r) / sectors) * glm::pi<float>();
        glm::vec3 xz = glm::vec3(ra * cosf(rad), 0, ra * sinf(rad));
        glm::vec3 rotated = glm::rotateZ(glm::rotateX(xz, -inclinations[s]), -azimuths[s]);
 
        vertexBuffer[idx] = p + rotated;
        glm::vec4 color;
        if (colors && colors.size()) {
          color = colors[r];
        }
        else {
          float col = glm::clamp((ra - r_min) / (r_max - r_min), 0.0f, 1.0f);
          size_t gs = gradient.size() - 1;
          float gsc = col * gs;
          size_t ia = glm::clamp<size_t>((size_t)glm::floor(gsc), 0, gs);
          size_t ib = glm::clamp(ia + 1, (size_t)0, gs);
          glm::vec3 a = gradient[ia];
          glm::vec3 b = gradient[ib];
          float t = glm::clamp((gsc - (float)ia), 0.0f, 1.0f);
          color = glm::vec4(glm::mix(a, b, t), 1.0);
        }
        colorsVector[idx] = color;
        idx++;
      }
    }
 
    size_t index_count = (sample_count - 1) * indexes_per_sample;
    mesh->primitiveType = PrimitiveType::EPrimitiveType::TriangleStrip;
    mesh->setPositions(vertexBuffer.data(), vertexBuffer.data() + vertexBuffer.size());
    mesh->setColors(colorsVector);
    mesh->setIndexData(indexBuffer.data(), index_count);
    meshComp->setChanged();
    this->setChanged();
 
    generateHighSide();
 
  }
 
  void RadialLogComponent::generateHighSide()  {
    const size_t sample_count = indexes.size();
    const size_t sectors = radiuses.size() / sample_count;
 
    if (highSide == nullptr) {
      auto entity = getContainer();
      highSide = context->store->createChildEntity("MeshPart", entity, "RadialLogHighSide");
    }
    MeshComponent* meshComp = highSide->getComponent<MeshComponent>();
    auto mesh = context->meshManager->createLocked();
    meshComp->meshHandle = mesh.getHandle();
    auto meshRenderComp = meshComp->getComponent<MeshRenderComponent>();
    if (meshRenderComp) meshRenderComp->material = instance;
 
    size_t vertex_count = sample_count * 2;
 
    std::vector<glm::vec3> vertexBuffer(vertex_count);
    std::vector<glm::vec4> colors(vertex_count);
    unsigned int idx = 0;
    for (size_t s = 0; s < sample_count; s++) {
      size_t r = high_side_index;
      size_t r_idx = s * sectors + r;
      size_t md_idx = s;
      for (size_t j = 0; j < 2; j++) {
 
        float ra = radiuses[r_idx] + j * high_side_size;
 
        float rad = glm::half_pi<float>() - 2.0f * (float(r) / sectors) * glm::pi<float>();
        glm::vec3 xz = glm::vec3(ra * cosf(rad), 0, ra * sinf(rad));
        glm::vec3 rotated = glm::rotateZ(glm::rotateX(xz, -inclinations[s]), -azimuths[s]);
 
        vertexBuffer[idx] = positions[md_idx] + rotated;
        colors[idx] = high_side_color;
        idx++;
      }
    }
 
    mesh->primitiveType = PrimitiveType::EPrimitiveType::TriangleStrip;
    mesh->setPositions(vertexBuffer.data(), vertexBuffer.data() + vertexBuffer.size());
    mesh->setColors(colors);
    meshComp->setChanged();
  }
 
 
}// namespace ...