CurtainViewSystem.cpp

#include "CurtainViewSystem.h"
 
#include "Resources/MaterialManager.h"
#include "Resources/MeshManager.h"
#include "Resources/TextureManager.h"
 
#include "Components/Core/MeshComponent.h"
#include "Components/Core/MeshRenderComponent.h"
 
void Cogs::Core::CurtainView::CurtainViewSystem::initialize(Context *context)
{
  ComponentSystemWithDataPool::initialize(context);
}
void Cogs::Core::CurtainView::CurtainViewSystem::update(Context * context)
{
  for (auto & component : pool) {
    CurtainViewData &data = getData(&component);
    auto entity = component.getContainer();
    // Swap resources
    if (data.uploading && data.texture[1]->isActive() && data.mesh[1]->isActive()) {
      data.uploading = false;
      // Swap Mesh
      auto tmp0 = data.mesh[0];
      data.mesh[0] = data.mesh[1];
      data.mesh[1] = tmp0;
      auto* meshComp = entity->getComponent<MeshComponent>();
      meshComp->meshHandle = data.mesh[0];
      meshComp->setChanged();
      // Swap textures
      TextureHandle tmp = data.texture[0];
      data.texture[0] = data.texture[1];
      data.texture[1] = tmp;
      auto key = material->getTextureKey("Velocity");
      data.material->setTextureAddressMode(key, SamplerState::Clamp);
      data.material->setTextureProperty(key, data.texture[0]);
    }
    if(!component.hasChanged()) continue;
    
    // Update Gradient
    {
      auto key = material->getTextureKey("Gradient");
      if(component.gradientClamp) data.material->setTextureAddressMode(key, SamplerState::Clamp);
      else data.material->setTextureAddressMode(key, SamplerState::Wrap);
      data.material->setTextureProperty(key, component.gradient);
    }
    // Update Material Data
    {
      float mul = 1.0f/(component.max-component.min);
      float add = -component.min*mul;
      data.material->setProperty("gradientMul", &mul, sizeof(mul));
      data.material->setProperty("gradientAdd", &add, sizeof(add));
      data.material->setVariant("ShadedCurtain", component.shadedCurtain);
      data.material->setProperty("gloss", &component.gloss, sizeof(component.gloss));
      data.material->setProperty("specular", &component.specular, sizeof(component.specular));
    }
    // Set Material
    {
      auto meshRenderComp = entity->getComponent<MeshRenderComponent>();
      meshRenderComp->material = data.material;
      meshRenderComp->setChanged();
    }
    // Upload resources
    if(data.uploading) continue;
    if(component.positions == nullptr || component.positions.size() <= 1 || component.depth <= 1) continue;
    data.uploading = true;
    {
      uint32_t width = (uint32_t)component.positions.size();
      uint32_t mesh_height = 2;
      std::vector<glm::vec3> vertexBuffer(width*mesh_height);
      std::vector<glm::vec2> texCoordBuffer(width*mesh_height);
      for(uint32_t w=0; w<width; w++){
        glm::vec3 p0 = component.positions[w];
        glm::vec3 p1 = component.end[w];
 
        int sampleOffset = component.sampleOffsets[w];
        int numSamples = component.samples[w];
        float firstTextureCoord = sampleOffset / (float)component.depth;
        float lastTextureCoord = (sampleOffset + numSamples) / (float)component.depth;
 
        for(uint32_t h=0; h<mesh_height; h++){
          uint32_t idx = w*mesh_height+h;
          float rate = h/(float)(mesh_height-1);
          glm::vec3 p = p0*(1.0f-rate) + p1*(rate);
          vertexBuffer[idx] = p;
 
          float tx = firstTextureCoord * (1.0f-rate) + lastTextureCoord *rate;
          texCoordBuffer[idx] = glm::vec2(tx, (w+0.5f)/(float)(width));
        }
      }
      std::vector<uint32_t> indexBuffer(width*2*(mesh_height-1) + (mesh_height-2)*2);
      for(uint32_t h=0; h<mesh_height-1; h++){
        for(uint32_t w=0; w<width; w++){
          uint32_t idx = (h*width+w)*2 + h*2;
          if(w==0 && h!=0) indexBuffer[idx-1] = w*mesh_height+h;
          indexBuffer[idx+0] = w*mesh_height+h;
          indexBuffer[idx+1] = w*mesh_height+(h+1);
          if(w==width-2 && h!=mesh_height-2) indexBuffer[idx+4] = (w+1)*mesh_height+(h+1);
        }
      }
      std::vector<glm::vec3> normalBuffer(width*mesh_height, glm::vec3(0.0));
      for(uint32_t h=0; h<mesh_height-1; h++){
        for(uint32_t w=0; w<(width-1); w++){
          int ia = w*mesh_height+h;
          int ib = w*mesh_height+(h+1);
          int ic = (w+1)*mesh_height+h;
          int id = (w+1)*mesh_height+(h+1);
          glm::vec3 a = vertexBuffer[ia];
          glm::vec3 b = vertexBuffer[ib];
          glm::vec3 c = vertexBuffer[ic];
          glm::vec3 d = vertexBuffer[id];
          glm::vec3 na = glm::cross(b-a, c-a);
          glm::vec3 nb = glm::cross(c-d, b-d);
          normalBuffer[ia] += na;
          normalBuffer[ib] += na + nb;
          normalBuffer[ic] += na + nb;
          normalBuffer[id] += nb;
        }
      }
      for(uint32_t i=0; i<normalBuffer.size(); i++)
        normalBuffer[i] = glm::normalize(normalBuffer[i]);
      MeshHandle &mesh = data.mesh[1];
      mesh->primitiveType = PrimitiveType::EPrimitiveType::TriangleStrip;
      mesh->setPositions(vertexBuffer.data(), vertexBuffer.data()+vertexBuffer.size());
      mesh->setNormals(normalBuffer.data(), normalBuffer.data()+normalBuffer.size());
      mesh->setTexCoords(texCoordBuffer.data(), texCoordBuffer.data()+texCoordBuffer.size());
      mesh->setIndexes(std::move(indexBuffer));
    }
    // Update Velocity
    {
      ResourceId id = data.texture->getId();
      TextureFormat format = TextureFormat::R32_FLOAT;
      int width = (int)component.positions.size();
      int stride = 0;
      data.texture[1] = context->textureManager->loadTexture2D((void*)component.velocity.data(), component.depth, width, format, stride, id, TextureLoadFlags::LinearColorSpace);
    }
  }
}
 
ComponentHandle Cogs::Core::CurtainView::CurtainViewSystem::createComponent()
{
  material = context->materialManager->loadMaterial("Materials/Curtain.material");
  context->materialManager->processLoading();
 
  ComponentHandle handle = ComponentSystemWithDataPool::createComponent();
  CurtainViewComponent *component = handle.resolveComponent<CurtainViewComponent>();
  CurtainViewData &data = getData(component);
 
  data.material = context->materialInstanceManager->createMaterialInstance(material);
  data.mesh[0] = context->meshManager->create();
  data.mesh[1] = context->meshManager->create();
  data.texture[0] = context->textureManager->getOrCreate(context->textureManager->getNextResourceId());
  data.texture[1] = context->textureManager->getOrCreate(context->textureManager->getNextResourceId());
 
  if(component->gradient == TextureHandle::NoHandle){
    component->gradient = context->textureManager->getOrCreate(context->textureManager->getNextResourceId());
    uint32_t colors[] = {0xfff9fb15, 0xfff8ba3d, 0xff81cc59, 0xff0bbdbd, 0xff2b91ef, 0xff4758f8, 0xff3e26a8};
    TextureFormat format = TextureFormat::R8G8B8A8_UNORM_SRGB;
 
    for(size_t i=0; i<sizeof(colors)/sizeof(colors[0]); i++){
      uint32_t color = colors[i];
      uint32_t ret = color; 
      ret = ret & 0xff000000;
      ret |= (((uint32_t)(powf(((color>>0)&0xff)*(1.0f/255.0f), 1.0f/2.2f)*255.0f))&0xff)<<0;
      ret |= (((uint32_t)(powf(((color>>8)&0xff)*(1.0f/255.0f), 1.0f/2.2f)*255.0f))&0xff)<<8;
      ret |= (((uint32_t)(powf(((color>>16)&0xff)*(1.0f/255.0f), 1.0f/2.2f)*255.0f))&0xff)<<16;
      colors[i] = ret;
    }
 
    TextureLoadInfo info = TextureLoadInfo();
    info.resourceId = component->gradient->getId();
    info.target = ResourceDimensions::Texture2D;
    info.resourceData.resize(sizeof(colors));
    memcpy(info.resourceData.data(), (const void*)&colors[0], sizeof(colors));
    info.loadFlags = (ResourceLoadFlags)TextureLoadFlags::None;
    info.handle = component->gradient;
    info.format = format;
    if(component->gradientClamp)
      info.addressMode = SamplerState::AddressMode::Clamp;
    else
      info.addressMode = SamplerState::AddressMode::Wrap;
    info.width = static_cast<int>(sizeof(colors)/sizeof(colors[0]));
    info.height = 1;
    info.depth = 1;
    info.stride = 0;
    info.flip = 0;
    info.preloading = false;
    context->textureManager->loadFromData(&info);
    assert((component->gradient->description.flags & TextureFlags::GenerateMipMaps) == 0);
    component->gradient->description.target = ResourceDimensions::Texture2D;
  }
 
  return handle;
}