You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
100 lines
3.1 KiB
100 lines
3.1 KiB
#include "common_cuda.h"
|
|
#include "render_gpu.h"
|
|
|
|
template <typename T>
|
|
RendererGpu<T>::RendererGpu(const Camera<T> cam, const Shader<T> shader, Buffer<T> buffer) : BaseRenderer<T>(cam, shader, buffer) {
|
|
if(buffer.depth != nullptr) {
|
|
buffer_gpu.depth = device_malloc<T>(cam.num_pixel());
|
|
}
|
|
|
|
if(buffer.color != nullptr) {
|
|
buffer_gpu.color = device_malloc<T>(cam.num_pixel() * 3);
|
|
}
|
|
|
|
if(buffer.normal != nullptr) {
|
|
buffer_gpu.normal = device_malloc<T>(cam.num_pixel() * 3);
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
RendererGpu<T>::~RendererGpu() {
|
|
device_free(buffer_gpu.depth);
|
|
device_free(buffer_gpu.color);
|
|
device_free(buffer_gpu.normal);
|
|
}
|
|
|
|
template <typename T>
|
|
void RendererGpu<T>::gpu_to_cpu() {
|
|
if(buffer_gpu.depth != nullptr && this->buffer.depth != nullptr) {
|
|
device_to_host(buffer_gpu.depth, this->buffer.depth, this->cam.num_pixel());
|
|
}
|
|
if(buffer_gpu.color != nullptr && this->buffer.color != nullptr) {
|
|
device_to_host(buffer_gpu.color, this->buffer.color, this->cam.num_pixel() * 3);
|
|
}
|
|
if(buffer_gpu.normal != nullptr && this->buffer.normal != nullptr) {
|
|
device_to_host(buffer_gpu.normal, this->buffer.normal, this->cam.num_pixel() * 3);
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
RenderInput<T> RendererGpu<T>::input_to_device(const RenderInput<T> input) {
|
|
RenderInput<T> input_gpu;
|
|
input_gpu.n_verts = input.n_verts;
|
|
input_gpu.n_faces = input.n_faces;
|
|
|
|
if(input.verts != nullptr) {
|
|
input_gpu.verts = host_to_device_malloc(input.verts, input.n_verts * 3);
|
|
}
|
|
if(input.colors != nullptr) {
|
|
input_gpu.colors = host_to_device_malloc(input.colors, input.n_verts * 3);
|
|
}
|
|
if(input.normals != nullptr) {
|
|
input_gpu.normals = host_to_device_malloc(input.normals, input.n_verts * 3);
|
|
}
|
|
if(input.faces != nullptr) {
|
|
input_gpu.faces = host_to_device_malloc(input.faces, input.n_faces * 3);
|
|
}
|
|
|
|
return input_gpu;
|
|
}
|
|
|
|
template <typename T>
|
|
void RendererGpu<T>::input_free_device(const RenderInput<T> input) {
|
|
if(input.verts != nullptr) {
|
|
device_free(input.verts);
|
|
}
|
|
if(input.colors != nullptr) {
|
|
device_free(input.colors);
|
|
}
|
|
if(input.normals != nullptr) {
|
|
device_free(input.normals);
|
|
}
|
|
if(input.faces != nullptr) {
|
|
device_free(input.faces);
|
|
}
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
void RendererGpu<T>::render_mesh(RenderInput<T> input) {
|
|
RenderInput<T> input_gpu = this->input_to_device(input);
|
|
RenderMeshFunctor<T> functor(input_gpu, this->shader, this->cam, this->buffer_gpu);
|
|
iterate_cuda(functor, this->cam.num_pixel());
|
|
gpu_to_cpu();
|
|
this->input_free_device(input_gpu);
|
|
}
|
|
|
|
template <typename T>
|
|
void RendererGpu<T>::render_mesh_proj(const RenderInput<T> input, const Camera<T> proj, const float* pattern, float d_alpha, float d_beta) {
|
|
RenderInput<T> input_gpu = this->input_to_device(input);
|
|
float* pattern_gpu = host_to_device_malloc(pattern, proj.num_pixel()*3);
|
|
|
|
RenderProjectorFunctor<T> functor(input_gpu, this->shader, this->cam, proj, pattern_gpu, d_alpha, d_beta, this->buffer_gpu);
|
|
iterate_cuda(functor, this->cam.num_pixel());
|
|
|
|
gpu_to_cpu();
|
|
this->input_free_device(input_gpu);
|
|
device_free(pattern_gpu);
|
|
}
|
|
|
|
template class RendererGpu<float>;
|
|
|