Sample Scene for Project Discussion with TA

.gitignore

@@ -67,7 +67,6 @@ StyleCopReport.xml
 *_h.h
 *.ilk
 *.meta
-*.obj
 *.iobj
 *.pch
 *.pdb

OpenWindow/improv_gfx.cpp

@@ -1,18 +1,27 @@
 #include "improv_gfx.h"
 
+Model *octopus, *ocean, *sharky;
+
 void Setup() {
-
+	octopus = new Model("octojet.obj", 1);
-	AddModel(new Model("sakura.obj"));
+	octopus->scale(Vec3f(4, 4, 4));
-
+	//octopus->translate(Vec3f(0, -0.15, 0));
-	AddModel(new Model("african_head.obj"));
+	octopus->ApplyTransform();
-
+	AddModel(octopus);
-	Model* model2 = new Model("african_head.obj");
+	ocean = new Model("ocean.obj", 1);
-	model2->translate(Vec3f(1, 0, 0));
+	ocean->scale(Vec3f(1, 1, 1));
-	model2->ApplyTransform();
+	ocean->ApplyTransform();
-	AddModel(model2);
+	AddModel(ocean);
-
+	sharky = new Model("sharky.obj", 0);
-	Model* model3 = new Model("african_head.obj");
+	sharky->scale(Vec3f(0.02, 0.02, 0.02));
-	model3->translate(Vec3f(-1, 0, 0));
+	sharky->translate(Vec3f(0, 0.05, 0));
-	model3->ApplyTransform();
+	sharky->ApplyTransform();
-	AddModel(model3);
+	AddModel(sharky);
+}
+
+void Draw() {
+	sharky->translate(Vec3f(sharky->Translation[0][3] + 0.01*cos(TIME), sharky->Translation[1][3], sharky->Translation[2][3] + 0.01*sin(TIME)));
+	sharky->rotate(Vec3f(0, (cos(TIME) + sin(TIME)) * -90, 0));
+	sharky->ApplyTransform();
+
 }

OpenWindow/improv_gfx.h

@@ -2,8 +2,10 @@
 #define __IMPROV_GFX__
 #include "model.h"
 #include "geometry.h"
+#include "renderer.h"
 
 void Setup();
+void Draw();
 void AddModel(Model* model);
 
 #endif

OpenWindow/kernels.cpp

@@ -1,5 +1,5 @@
 #include "kernels.h"
-#include "util_window.h"
+#include "renderer.h"
 #include <debugapi.h>
 #include <ctime>
 #include <climits>
@@ -14,6 +14,7 @@ cl_context context;
 int* hidden_pixel_buffer;
 cl_mem z_buffer_mem;
 cl_mem pixel_data_buffer;
+cl_mem time_buffer;
 //==================
 
 cl_platform_id* platforms = NULL;
@@ -40,6 +41,7 @@ void init_kernels() {
 	hidden_pixel_buffer = new int[screen_width*screen_height];
 	pixel_data_buffer  = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(int) * screen_height * screen_width  , NULL, &err);
 	z_buffer_mem       = clCreateBuffer(context, CL_MEM_READ_ONLY , sizeof(float) * screen_height * screen_width, NULL, &err);
+	time_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(float), NULL, &err);
 }
 
 
@@ -50,6 +52,8 @@ void clear(cl_mem* buffer, size_t size, const int pattern) {
 void new_frame() {
 	clear(&pixel_data_buffer, sizeof(int) * screen_width * screen_height, 0);
 	clear(&z_buffer_mem, sizeof(float) * screen_width * screen_height, 0);
+	clEnqueueWriteBuffer(commands, time_buffer, CL_TRUE, 0, sizeof(float), &TIME, 0, NULL, NULL);
+	clFinish(commands);
 }
 
 void end_frame() {
@@ -65,6 +69,7 @@ void destroy_kernels()
 {
 	clReleaseMemObject(z_buffer_mem);
 	clReleaseMemObject(pixel_data_buffer);
+	clReleaseMemObject(time_buffer);
 	clReleaseCommandQueue(commands);
 
 	free(hidden_pixel_buffer);

OpenWindow/kernels.h

@@ -3,6 +3,7 @@
 #include <Windows.h>
 #include <CL/cl.h>
 #include "geometry.h"
+#include "util_window.h"
 
 
 extern cl_uint numPlatforms;
@@ -31,6 +32,7 @@ extern const char* matrix_mul_kernel_source;
 
 extern const char* vertex_shader_kernel_source;
 extern const char* fragment_shader_kernel_source;
+extern const char* fluid_vertex_shader_kernel_source;
 
 extern cl_command_queue commands;
 extern cl_platform_id* platforms;
@@ -39,6 +41,7 @@ extern cl_context context;
 
 extern cl_mem z_buffer_mem;
 extern cl_mem pixel_data_buffer;
+extern cl_mem time_buffer;
 
 void init_kernels();
 void destroy_kernels();

OpenWindow/main.cpp

@@ -75,7 +75,7 @@ bool HandleButtonPressed() {
 
 void CALLBACK FixedUpdate(HWND hwnd, UINT message, UINT uInt, DWORD dWord)
 {
-	TIME += 0.03333333;
+	TIME += 1.f / (float)TARGET_FRAMERATE;
 	HandleButtonPressed();
 	camera.ApplyChanges();
 	clock_t start = clock();

OpenWindow/model.cpp

@@ -6,7 +6,8 @@
 #define PI 3.14159265358979323846
 #define DEG2RAD PI/180
 
-Model::Model(const char *filename) : verts_(), faces_(), norms_(), uv_(), diffusemap_(), normalmap_(), specularmap_() {
+Model::Model(const char *filename, int watery) : verts_(), faces_(), norms_(), uv_(), diffusemap_(), normalmap_(), specularmap_() {
+	fluid = watery;
     std::ifstream in;
 	Transform = Matrix::identity();
 	Rotation = Matrix::identity();
@@ -45,10 +46,7 @@ Model::Model(const char *filename) : verts_(), faces_(), norms_(), uv_(), diffus
             faces_.push_back(f);
         }
     }
-    //std::cerr << "# v# " << verts_.size() << " f# "  << faces_.size() << " vt# " << uv_.size() << " vn# " << norms_.size() << std::endl;
     load_texture(filename, "_diffuse.tga", diffusemap_);
-    //load_texture(filename, "_nm_tangent.tga",      normalmap_);
-    //load_texture(filename, "_spec.tga",    specularmap_);
 	init_kernels();
 }
 
@@ -112,7 +110,7 @@ void Model::load_texture(std::string filename, const char *suffix, TGAImage &img
     if (dot!=std::string::npos) {
         texfile = texfile.substr(0,dot) + std::string(suffix);
         std::cerr << "texture file " << texfile << " loading " << (img.read_tga_file(texfile.c_str()) ? "ok" : "failed") << std::endl;
-        img.flip_vertically();
+        //img.flip_vertically();
     }
 }
 
@@ -145,6 +143,9 @@ Vec3f Model::normal(int iface, int nthvert) {
 }
 
 void Model::init_kernels() {
+	if(fluid)
+		vertex_shader_prog = clCreateProgramWithSource(context, 1, (const char **)&fluid_vertex_shader_kernel_source, NULL, &err);
+	else
 		vertex_shader_prog = clCreateProgramWithSource(context, 1, (const char **)&vertex_shader_kernel_source, NULL, &err);
 	err = clBuildProgram(vertex_shader_prog, 1, devices, NULL, NULL, NULL);
 	vertex_shader_kernel = clCreateKernel(vertex_shader_prog, "vertex_shader", &err);
@@ -155,6 +156,7 @@ void Model::init_kernels() {
 	clSetKernelArg(vertex_shader_kernel, 0, sizeof(cl_mem), &vertex_shader_matz);
 	clSetKernelArg(vertex_shader_kernel, 1, sizeof(cl_mem), &vertex_shader_vertices);
 	clSetKernelArg(vertex_shader_kernel, 2, sizeof(cl_mem), &new_vertices_mem);
+	clSetKernelArg(vertex_shader_kernel, 3, sizeof(cl_mem), &time_buffer);
 	clEnqueueWriteBuffer(commands, vertex_shader_vertices, CL_TRUE, 0, sizeof(float) * nverts() * 3, *(float**)((Vec3f*) &verts_), 0, NULL, NULL);
 
 	int map_size[] = { diffusemap_.get_width(), diffusemap_.get_height() };
@@ -242,15 +244,42 @@ void Model::release_kernels() {
 }
 
 
+const char* fluid_vertex_shader_kernel_source =
+"__kernel                                                                                                                    \n"
+"void vertex_shader( __global float* m,                                                                                      \n"
+"                    __global float* VertexBuffer,                                                                           \n"
+"                    __global float* NewVertexBuffer,                                                                        \n"
+"                    __global float* TIME           )                                                                        \n"
+"{                                                                                                                           \n"
+"    int local_index = get_local_id(0);                                                                                      \n"
+"    int global_index = get_group_id(0);                                                                                     \n"
+"    float AMPLITUDE = 5;                                                                                     \n"
+"    float FREQ = 2.0f;                                                                                     \n"
+"                                                                                                                            \n"
+"    float offset = 0.f;                                                                                                     \n"
+"    if(local_index == 1) {                                                                                                  \n"
+"    offset = (sin(TIME[0]*(fmod(10-VertexBuffer[3*global_index],5.f) * FREQ)) + sin(TIME[0]*(fmod(10-VertexBuffer[3*global_index+2], 5.f))*FREQ)) * AMPLITUDE;                                                                                                \n"
+"    }                                                                                                                       \n"
+"                                                                                                                            \n"
+"    NewVertexBuffer[4*global_index+local_index] =                                                                           \n"
+"						  m[local_index*4]*VertexBuffer[3*global_index]                                                      \n"
+"	                    + m[local_index*4 + 1]*VertexBuffer[3*global_index+1]                                                \n"
+"	                    + m[local_index*4 + 2]*VertexBuffer[3*global_index+2]                                                \n"
+"	                    + m[local_index*4 + 3]                                                                               \n"
+"	                    + offset;                                                                                            \n"
+"}                                                                                                                           \n";
+
 
 const char* vertex_shader_kernel_source =
 "__kernel                                                                                                                    \n"
 "void vertex_shader( __global float* m,                                                                                      \n"
 "                    __global float* VertexBuffer,                                                                           \n"
-"                    __global float* NewVertexBuffer)                                                                        \n"
+"                    __global float* NewVertexBuffer,                                                                        \n"
+"                    __global float* TIME           )                                                                        \n"
 "{                                                                                                                           \n"
 "    int local_index = get_local_id(0);                                                                                      \n"
 "    int global_index = get_group_id(0);                                                                                     \n"
+"                                                                                                                            \n"
 "    NewVertexBuffer[4*global_index+local_index] =                                                                           \n"
 "						  m[local_index*4]*VertexBuffer[3*global_index]                                                      \n"
 "	                    + m[local_index*4 + 1]*VertexBuffer[3*global_index+1]                                                \n"

OpenWindow/model.h

@@ -10,6 +10,7 @@
 class Model {
 private:
     void load_texture(std::string filename, const char *suffix, TGAImage &img);
+	int fluid;
 public:
     TGAImage diffusemap_;
     TGAImage normalmap_;
@@ -34,7 +35,7 @@ public:
 	cl_mem fragment_shader_diffuse_map;
 	cl_int3* faces;
 
-    Model(const char *filename);
+    Model(const char *filename, int watery);
     ~Model();
     int nverts();
     int nfaces();

OpenWindow/renderer.cpp

@@ -17,7 +17,7 @@
 #define NEAR_CLIP_PLANE                    1.f 
 #define FAR_CLIP_PLANE                     2000.0f
 #define FOV                                50
-#define CAMERA_MOVEMENT_SPEED              .7f
+#define CAMERA_MOVEMENT_SPEED              .1f
 #define DEFAULT_CAMERA_POS     Vec3f(0, 0, 5)
 #define DEFAULT_CAMERA_ROT     Vec3f(0, 0, 0)
 #define LIGHT_INTENSITY                   1.5
@@ -29,7 +29,7 @@ Matrix Projection = Matrix::identity();
 Model* model, *model2;
 Camera camera;
 
-Vec3f light_dir = Vec3f(1, 1, 1).normalize();
+Vec3f light_dir = Vec3f(0, 1, 1).normalize();
 bool init_flag = false;
 
 void init_camera() {
@@ -66,6 +66,7 @@ void render()
 	Matrix z = ViewPort * Projection * ModelView;
 
 	new_frame();
+	Draw();
 	for(Model* model : models_in_scene)
 		model->render(&z, (float*)&light_dir);
 	end_frame();