TransformVertices.h

#pragma once
#include "Base.h"
#include <vector>
#include <glm/glm.hpp>
 
namespace Cogs
{
  namespace Core
  {
    class Context;
 
 
 
    COGSCORE_DLL_API void transformVertex3ToVertex4(Context* context,
                                                    uint8_t* dst,
                                                    const size_t dst_stride,
                                                    const size_t dst_bytes,
                                                    const glm::mat4& matrix,
                                                    const uint8_t* src,
                                                    const size_t src_stride,
                                                    const size_t src_bytes,
                                                    const size_t src_count);
 
    inline void transformVertices(Context* context,
                                  std::vector<glm::vec4>& dst,
                                  const glm::mat4& matrix,
                                  const std::vector<glm::vec3>& src)
    {
      transformVertex3ToVertex4(context,
                                reinterpret_cast<uint8_t*>(dst.data()),
                                sizeof(glm::vec4),
                                sizeof(glm::vec4)*dst.size(),
                                matrix,
                                reinterpret_cast<const uint8_t*>(src.data()),
                                sizeof(glm::vec3),
                                sizeof(glm::vec3)*src.size(),
                                src.size());
    }
 
    inline void transformVertices(Context* context,
                                  std::vector<glm::vec4>& dst,
                                  const glm::mat4& matrix,
                                  const std::vector<glm::vec3>& src,
                                  size_t offset,
                                  size_t count )
    {
#ifdef _DEBUG
      assert(offset + count <= src.size());
#endif
      transformVertex3ToVertex4(context,
                                reinterpret_cast<uint8_t*>(dst.data()),
                                sizeof(glm::vec4),
                                sizeof(glm::vec4)*dst.size(),
                                matrix,
                                reinterpret_cast<const uint8_t*>(src.data()+offset),
                                sizeof(glm::vec3),
                                sizeof(glm::vec3)*(src.size()-offset),
                                count);
    }
 
 
 
  }
}