added image textures

Author: joaovbs96

OptiX-Path-Tracer/CMakeLists.txt

@@ -28,6 +28,7 @@ cuda_compile_and_embed( embedded_constant_texture_programs programs/textures/con
 cuda_compile_and_embed( embedded_aarect_programs programs/hitables/aarect.cu )
 cuda_compile_and_embed( embedded_checker_texture_programs programs/textures/checkered_texture.cu )
 cuda_compile_and_embed( embedded_noise_texture_programs programs/textures/noise_texture.cu )
+cuda_compile_and_embed( embedded_image_texture_programs programs/textures/image_texture.cu )
 
 # this is doing the same using OptiX
 add_executable(OptiX-Path-Tracer
@@ -54,6 +55,7 @@ add_executable(OptiX-Path-Tracer
   ${embedded_aarect_programs}
   ${embedded_checker_texture_programs}
   ${embedded_noise_texture_programs}
+  ${embedded_image_texture_programs}
   )
 
 target_link_libraries(OptiX-Path-Tracer

OptiX-Path-Tracer/host_includes/scenes.h

@@ -37,7 +37,7 @@ optix::GeometryGroup InOneWeekend(optix::Context &g_context, Camera &camera, int
     }
   }
   d_list.push_back(createSphere(vec3f(-4.f, 1.f, 0.f), 1.f, Dielectric(1.5f), g_context));
-  d_list.push_back(createSphere(vec3f(4.f, 1.f, 0.f), 1.f, Lambertian(new Noise_Texture(4.f)), g_context));
+  d_list.push_back(createSphere(vec3f(4.f, 1.f, 0.f), 1.f, Lambertian(new Image_Texture("assets/map.jpg")), g_context));
   d_list.push_back(createSphere(vec3f(0.f, 1.f, 0.f), 1.f, Metal(new Constant_Texture(vec3f(0.7f, 0.6f, 0.5f)), 0.0f), g_context));
   //createBox(vec3f(0.3f, 0.5f, 0.6f), vec3f(3.55f, 3.f, 3.2f), Lambertian(new Constant_Texture(vec3f(rnd()*rnd(), rnd()*rnd(), rnd()*rnd()))), g_context, d_list);
 

OptiX-Path-Tracer/host_includes/textures.h

@@ -7,6 +7,15 @@
 
 #include "../programs/vec.h"
 
+// Image I/O - disregard lib warnings
+#pragma warning(push, 0)        
+#define STBI_MSC_SECURE_CRT
+#define STB_IMAGE_IMPLEMENTATION
+#include "../lib/stb_image.h"
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "../lib/stb_image_write.h"
+#pragma warning(pop)
+
 float rnd() {
   // static std::random_device rd;  //Will be used to obtain a seed for the random number engine
   static std::mt19937 gen(0); //Standard mersenne_twister_engine seeded with rd()
@@ -22,6 +31,7 @@ float rnd() {
 extern "C" const char embedded_constant_texture_programs[];
 extern "C" const char embedded_checker_texture_programs[];
 extern "C" const char embedded_noise_texture_programs[];
+extern "C" const char embedded_image_texture_programs[];
 
 struct Texture {
     virtual optix::Program assignTo(optix::GeometryInstance gi, optix::Context &g_context) const = 0;
@@ -123,4 +133,59 @@ struct Noise_Texture : public Texture{
     const float scale;
 };
 
+struct Image_Texture : public Texture{
+    Image_Texture(const std::string f) : fileName(f) {}
+
+    optix::TextureSampler loadTexture(optix::Context context, const std::string fileName) const {
+        int nx, ny, nn;
+        unsigned char *tex_data = stbi_load((char*)fileName.c_str(), &nx, &ny, &nn, 0);
+
+        optix::TextureSampler sampler = context->createTextureSampler();
+        sampler->setWrapMode(0, RT_WRAP_REPEAT);
+        sampler->setWrapMode(1, RT_WRAP_REPEAT);
+        sampler->setWrapMode(2, RT_WRAP_REPEAT);
+        sampler->setIndexingMode(RT_TEXTURE_INDEX_NORMALIZED_COORDINATES);
+        sampler->setReadMode(RT_TEXTURE_READ_NORMALIZED_FLOAT);
+        sampler->setMaxAnisotropy(1.0f);
+        sampler->setMipLevelCount(1u);
+        sampler->setArraySize(1u);
+        
+        optix::Buffer buffer = context->createBuffer(RT_BUFFER_INPUT, RT_FORMAT_UNSIGNED_BYTE4, nx, ny);
+        unsigned char * data = static_cast<unsigned char *>(buffer->map());
+        
+        for (int i = 0; i < nx; ++i) {
+            for (int j = 0; j < ny; ++j) {
+                int bindex = (j * nx + i) * 4;
+                int iindex = ((ny - j - 1) * nx + i) * nn;
+
+                data[bindex + 0] = tex_data[iindex + 0];
+                data[bindex + 1] = tex_data[iindex + 1];
+                data[bindex + 2] = tex_data[iindex + 2];
+                
+                if(nn == 4)
+                    data[bindex + 3] = tex_data[iindex + 3];
+                else//3-channel images
+                    data[bindex + 3] = (unsigned char)255;
+            }
+        }
+
+        buffer->unmap();
+        sampler->setBuffer(buffer);
+        sampler->setFilteringModes(RT_FILTER_LINEAR, RT_FILTER_LINEAR, RT_FILTER_NONE);
+        return sampler;
+    }
+    
+    virtual optix::Program assignTo(optix::GeometryInstance gi, optix::Context &g_context) const override {
+        optix::Program textProg = g_context->createProgramFromPTXString(embedded_image_texture_programs, "sample_texture");
+
+        textProg["data"]->setTextureSampler(loadTexture(g_context, fileName));
+
+        gi["sample_texture"]->setProgramId(textProg);
+
+        return textProg;
+    }
+    
+    const std::string fileName;
+};
+
 #endif

OptiX-Path-Tracer/main.cpp

@@ -25,15 +25,6 @@
 // that we can use host functions as usual in these headers.
 #include "host_includes/scenes.h"
 
-// Image I/O - disregard lib warnings
-#pragma warning(push, 0)        
-#define STBI_MSC_SECURE_CRT
-#define STB_IMAGE_IMPLEMENTATION
-#include "lib/stb_image.h"
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-#include "lib/stb_image_write.h"
-#pragma warning(pop)
-
 optix::Context g_context;
 
 /*! the precompiled programs/raygen.cu code (in ptx) that our
@@ -182,7 +173,7 @@ int main(int ac, char **av) {
 			arr[pixel_index + 2] = int(255.99 * clamp(col.z));
     }
 
-  std::string output = "output/perlin_1000.png";
+  std::string output = "output/image_1000.png";
   stbi_write_png((char*)output.c_str(), Nx, Ny, 3, arr, 0);
   fb->unmap();
 

OptiX-Path-Tracer/programs/hitables/aarect.cu

@@ -15,6 +15,8 @@ rtDeclareVariable(optix::Ray, ray, rtCurrentRay, );
 /*! the attributes we use to communicate between intersection programs and hit program */
 rtDeclareVariable(float3, hit_rec_normal, attribute hit_rec_normal, );
 rtDeclareVariable(float3, hit_rec_p, attribute hit_rec_p, );
+rtDeclareVariable(float, hit_rec_u, attribute hit_rec_u, );
+rtDeclareVariable(float, hit_rec_v, attribute hit_rec_v, );
 
 /*! the per ray data we operate on */
 rtDeclareVariable(PerRayData, prd, rtPayload, );
@@ -38,6 +40,8 @@ RT_PROGRAM void hit_rect_X(int pid) {
         if (rtPotentialIntersection(t)) {
           hit_rec_p = ray.origin + t * ray.direction;
           hit_rec_normal = normal;
+          hit_rec_u = (a - a0) / (a1 - a0);
+          hit_rec_v = (b - b0) / (b1 - b0);
           rtReportIntersection(0);
         }
     }
@@ -60,6 +64,8 @@ RT_PROGRAM void hit_rect_Y(int pid) {
         if (rtPotentialIntersection(t)) {
           hit_rec_p = ray.origin + t * ray.direction;
           hit_rec_normal = normal;
+          hit_rec_u = (a - a0) / (a1 - a0);
+          hit_rec_v = (b - b0) / (b1 - b0);
           rtReportIntersection(0);
         }
     }
@@ -78,6 +84,8 @@ RT_PROGRAM void hit_rect_Z(int pid) {
         if (rtPotentialIntersection(t)) {
           hit_rec_p = ray.origin + t * ray.direction;
           hit_rec_normal = normal;
+          hit_rec_u = (a - a0) / (a1 - a0);
+          hit_rec_v = (b - b0) / (b1 - b0);
           rtReportIntersection(0);
         }
     }

OptiX-Path-Tracer/programs/hitables/moving_sphere.cu

@@ -30,10 +30,20 @@ rtDeclareVariable(optix::Ray, ray, rtCurrentRay, );
 /*! the attributes we use to communicate between intersection programs and hit program */
 rtDeclareVariable(float3, hit_rec_normal, attribute hit_rec_normal, );
 rtDeclareVariable(float3, hit_rec_p, attribute hit_rec_p, );
+rtDeclareVariable(float, hit_rec_u, attribute hit_rec_u, );
+rtDeclareVariable(float, hit_rec_v, attribute hit_rec_v, );
 
 /*! the per ray data we operate on */
 rtDeclareVariable(PerRayData, prd, rtPayload, );
 
+inline __device__ void get_sphere_uv(const vec3f& p) {
+	float phi = atan2(p.z, p.x);
+	float theta = asin(p.y); 
+
+	hit_rec_u = 1 - (phi + CUDART_PI_F) / (2 * CUDART_PI_F);
+	hit_rec_v = (theta + CUDART_PI_F / 2) / CUDART_PI_F;
+}
+
 __device__ float3 center(float time) {
 	return center0 + ((time - time0) / (time1 - time0)) * (center1 - center0);
 }
@@ -71,6 +81,7 @@ RT_PROGRAM void hit_sphere(int pid) {
     if (rtPotentialIntersection(temp)) {
       hit_rec_p = ray.origin + temp * ray.direction;
       hit_rec_normal = (hit_rec_p - center(prd.in.time)) / radius;
+      get_sphere_uv((hit_rec_p - center(prd.in.time)) / radius);
       rtReportIntersection(0);
     }
   }
@@ -81,6 +92,7 @@ RT_PROGRAM void hit_sphere(int pid) {
     if (rtPotentialIntersection(temp)) {
       hit_rec_p = ray.origin + temp * ray.direction;
       hit_rec_normal = (hit_rec_p - center(prd.in.time)) / radius;
+      get_sphere_uv((hit_rec_p - center(prd.in.time)) / radius);
       rtReportIntersection(0);
     }
   }

OptiX-Path-Tracer/programs/hitables/sphere.cu

@@ -27,10 +27,20 @@ rtDeclareVariable(optix::Ray, ray, rtCurrentRay, );
 /*! the attributes we use to communicate between intersection programs and hit program */
 rtDeclareVariable(float3, hit_rec_normal, attribute hit_rec_normal, );
 rtDeclareVariable(float3, hit_rec_p, attribute hit_rec_p, );
+rtDeclareVariable(float, hit_rec_u, attribute hit_rec_u, );
+rtDeclareVariable(float, hit_rec_v, attribute hit_rec_v, );
 
 /*! the per ray data we operate on */
 rtDeclareVariable(PerRayData, prd, rtPayload, );
 
+inline __device__ void get_sphere_uv(const vec3f& p) {
+	float phi = atan2(p.z, p.x);
+	float theta = asin(p.y); 
+
+	hit_rec_u = 1 - (phi + CUDART_PI_F) / (2 * CUDART_PI_F);
+	hit_rec_v = (theta + CUDART_PI_F / 2) / CUDART_PI_F;
+}
+
 
 // Program that performs the ray-sphere intersection
 //
@@ -65,6 +75,7 @@ RT_PROGRAM void hit_sphere(int pid) {
     if (rtPotentialIntersection(temp)) {
       hit_rec_p = ray.origin + temp * ray.direction;
       hit_rec_normal = (hit_rec_p - center) / radius;
+      get_sphere_uv((hit_rec_p - center) / radius);
       rtReportIntersection(0);
     }
   }
@@ -75,6 +86,7 @@ RT_PROGRAM void hit_sphere(int pid) {
     if (rtPotentialIntersection(temp)) {
       hit_rec_p = ray.origin + temp * ray.direction;
       hit_rec_normal = (hit_rec_p - center) / radius;
+      get_sphere_uv((hit_rec_p - center) / radius);
       rtReportIntersection(0);
     }
   }

OptiX-Path-Tracer/programs/materials/dielectric.cu

@@ -26,6 +26,8 @@ rtDeclareVariable(rtObject,   world, , );
 /*! the attributes we use to communicate between intersection programs and hit program */
 rtDeclareVariable(float3, hit_rec_normal, attribute hit_rec_normal, );
 rtDeclareVariable(float3, hit_rec_p, attribute hit_rec_p, );
+rtDeclareVariable(float, hit_rec_u, attribute hit_rec_u, );
+rtDeclareVariable(float, hit_rec_v, attribute hit_rec_v, );
 
 /*! and finally - that particular material's parameters */
 rtDeclareVariable(float, ref_idx, , );
@@ -75,7 +77,12 @@ inline __device__ bool scatter(const optix::Ray &ray_in,
   return true;
 }
 
+inline __device__ float3 emitted(){
+  return make_float3(0.f, 0.f, 0.f);
+}
+
 RT_PROGRAM void closest_hit() {
+  prd.out.emitted = emitted();
   prd.out.scatterEvent
     = scatter(ray,
               *prd.in.randState,

OptiX-Path-Tracer/programs/materials/lambertian.cu

@@ -26,6 +26,8 @@ rtDeclareVariable(rtObject, world, , );
 /*! the attributes we use to communicate between intersection programs and hit program */
 rtDeclareVariable(float3, hit_rec_normal, attribute hit_rec_normal, );
 rtDeclareVariable(float3, hit_rec_p, attribute hit_rec_p, );
+rtDeclareVariable(float, hit_rec_u, attribute hit_rec_u, );
+rtDeclareVariable(float, hit_rec_v, attribute hit_rec_v, );
 
 // TODO: eventually UV parameters will be needed in the materials. 
 // These should be defined in the intersection/hitable programs.
@@ -47,13 +49,18 @@ inline __device__ bool scatter(const optix::Ray &ray_in,
   // return scattering event
   scattered_origin = hit_rec_p;
   scattered_direction = (target - hit_rec_p);
-  float3  color = sample_texture(0.f, 0.f, hit_rec_p);
+  float3  color = sample_texture(hit_rec_u, hit_rec_v, hit_rec_p);
   attenuation = vec3f(color);
   return true;
 }
 
+inline __device__ float3 emitted(){
+  return make_float3(0.f, 0.f, 0.f);
+}
+
 RT_PROGRAM void closest_hit() {
-   prd.out.scatterEvent
+  prd.out.emitted = emitted();
+  prd.out.scatterEvent
     = scatter(ray,
               *prd.in.randState,
               prd.out.scattered_origin,

OptiX-Path-Tracer/programs/materials/metal.cu

@@ -23,17 +23,16 @@ rtDeclareVariable(PerRayData, prd,   rtPayload, );
 rtDeclareVariable(rtObject,   world, , );
 
 
-
 /*! the attributes we use to communicate between intersection programs and hit program */
 rtDeclareVariable(float3, hit_rec_normal, attribute hit_rec_normal, );
 rtDeclareVariable(float3, hit_rec_p, attribute hit_rec_p, );
-
+rtDeclareVariable(float, hit_rec_u, attribute hit_rec_u, );
+rtDeclareVariable(float, hit_rec_v, attribute hit_rec_v, );
 
 /*! and finally - that particular material's parameters */
 rtDeclareVariable(rtCallableProgramId<float3(float, float, float3)>, sample_texture, , );
 rtDeclareVariable(float,  fuzz,   , );
 
-
 /*! the actual scatter function - in Pete's reference code, that's a
   virtual function, but since we have a different function per program
   we do not need this here */
@@ -46,12 +45,16 @@ inline __device__ bool scatter(const optix::Ray &ray_in,
   vec3f reflected = reflect(unit_vector(ray_in.direction),hit_rec_normal);
   scattered_origin    = hit_rec_p;
   scattered_direction = (reflected+fuzz*random_in_unit_sphere(rndState));
-  attenuation         = sample_texture(0.f, 0.f, hit_rec_p);
+  attenuation         = sample_texture(hit_rec_u, hit_rec_v, hit_rec_p);
   return (dot(scattered_direction, hrn) > 0.f);
 }
 
-RT_PROGRAM void closest_hit()
-{
+inline __device__ float3 emitted(){
+  return make_float3(0.f, 0.f, 0.f);
+}
+
+RT_PROGRAM void closest_hit() {
+  prd.out.emitted = emitted();
   prd.out.scatterEvent
     = scatter(ray,
               *prd.in.randState,