Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Annotation of /examples/iso2d-spatial/main.c
ViewVC logotype

Annotation of /examples/iso2d-spatial/main.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3013 - (view) (download) (as text)

1 : lamonts 2950 #define GL_GLEXT_PROTOTYPES
2 :     #define GLFW_INCLUDE_GLCOREARB
3 :     #include <GLFW/glfw3.h>
4 :     #if defined(__APPLE_CC__)
5 :     #include <OpenGL/glext.h>
6 :     #else
7 :     # include <GL/glext.h>
8 :     #endif
9 :     #include "utils/utils.h"
10 :     #include "utils/linmath.h"
11 :     #include "view.h"
12 :     #include "utils/circle.h"
13 :     #include "iso2d.h"
14 :     #include <unistd.h>
15 :     #include <stdlib.h>
16 :     #include <stdio.h>
17 :     #include "teem/nrrd.h"
18 :    
19 :     /* pixel dimensions of output */
20 :     #define WIDTH 990
21 :     #define HEIGHT 990
22 :    
23 :    
24 :     View * view = NULL;
25 :    
26 :     typedef enum {
27 :     RED = 0,
28 :     BLUE = 1
29 :     }Colors;
30 :    
31 :     typedef struct {
32 :     ISO_World_t * wrld;
33 :     Nrrd * snapData;
34 :     Circle * particles;
35 :    
36 :     }DiderotProg_t;
37 :    
38 :     DiderotProg_t dProg;
39 :    
40 :     static void getData (ISO_World_t *wrld, Nrrd *nData);
41 :     void display (GLFWwindow *win);
42 :    
43 :     /* Set the viewport to the current size of the framebufffer.
44 :     * We use the framebuffer size instead of the window size, because they
45 :     * are different on Apple's retina displays.
46 :     */
47 :     static void setViewPort (GLFWwindow *window)
48 :     {
49 :     int fbWid, fbHt;
50 :     glfwGetFramebufferSize (window, &fbWid, &fbHt);
51 :     glViewport(0, 0 , fbWid, fbHt);
52 :     }
53 :    
54 :     /** Initializes the diderot program */
55 :     static void diderot_init(GLFWwindow *window)
56 :     {
57 :     dProg.wrld = ISO_Init();
58 :     dProg.snapData = nrrdNew();
59 :     if(ISO_Initially (dProg.wrld)) {
60 :     fprintf(stderr,"Error initializing the world\n");
61 :     exit(EXIT_FAILURE);
62 :     }
63 :    
64 :     unsigned int nParticles = ISO_NumStrands (dProg.wrld);
65 :     float r = 0.0035;
66 :     // ISO_InVarGet_rr(dProg.wrld, &r);
67 :     vec4 color = {1.0f, 1.0f,0.0f,1.0f};
68 :     dProg.particles = circle_create(nParticles,r,color);
69 :    
70 :     getData (dProg.wrld, dProg.snapData);
71 :     display(window);
72 :     }
73 :     static void getData (ISO_World_t *wrld, Nrrd *nData)
74 :     {
75 :     // get snapshot of state
76 : lamonts 3013 if (ISO_Snapshot_pos(wrld, nData)) {
77 : lamonts 2950 // error
78 :     fprintf(stderr, "Error getting nrrd data\n");
79 :     exit(1);
80 :     }
81 :     if(dProg.particles != NULL) {
82 :     float *particles = (float *)(nData->data);
83 :     unsigned int nParticles = ISO_NumStrands (wrld);
84 :     mat4x4 trans;
85 :     mat4x4 final;
86 :     for(int i = 0; i < nParticles; i++)
87 :     {
88 :     int idx = i * 2;
89 :     float x = particles[idx];
90 :     float y = particles[idx + 1] ;
91 :     mat4x4_identity(final);
92 :     mat4x4_identity(trans);
93 :     mat4x4_identity(dProg.particles->models[i]);
94 :     mat4x4_translate(trans, x, y, 1.0);
95 :     mat4x4_mul(dProg.particles->models[i],trans, final);
96 :     }
97 :     }
98 :     }
99 :     /***** Callback functions *****/
100 :     static void error (int err, const char *msg)
101 :     {
102 :     fprintf(stderr,"[GLFW ERROR(%d): %s\n", err,msg);
103 :     }
104 :    
105 :     void display (GLFWwindow *win)
106 :     {
107 :     //RENDER
108 :     view_render(dProg.particles,view);
109 :     glfwSwapBuffers (win);
110 :    
111 :     } /* end of Display */
112 :     void step(GLFWwindow *win) {
113 : lamonts 3013 static bool first = true;
114 : lamonts 2950 if(ISO_NumActive(dProg.wrld) > 0){
115 :     // step the computation
116 :     ISO_Run(dProg.wrld, STEP_SIZE);
117 :     // get and render the state
118 :     getData (dProg.wrld, dProg.snapData);
119 : lamonts 3013 }else {
120 :     if(first){
121 :     printf("Finished Running\n");
122 :     first = false;
123 :     }
124 : lamonts 2950 }
125 :     }
126 :    
127 :     void reshape (GLFWwindow *win, int wid, int ht)
128 :     {
129 :    
130 :     /* set the viewport */
131 :     setViewPort(win);
132 :    
133 :     /* recompute the projection matrix */
134 :     // view->initProjMatrix ();
135 :    
136 :     } /* end of Reshape */
137 :     static void key_callback(GLFWwindow* win, int key, int scancode, int action, int mods)
138 :     {
139 :     if (key == GLFW_KEY_RIGHT && action == GLFW_PRESS)
140 :     {
141 :     step(win);
142 :     display(win);
143 :     }
144 :     }
145 :    
146 :     void key (GLFWwindow *win, unsigned int key)
147 :     {
148 :     switch(key){
149 :     case GLFW_KEY_RIGHT:
150 :     {
151 :     printf("<1>\n");
152 :     step(win);
153 :     display(win);
154 :     }
155 :     //view->showBlendedCube = !view->showBlendedCube;
156 :     break;
157 :     }
158 :    
159 :     } /* end of Key */
160 :    
161 :     /*! \brief the main function for the program
162 :     * \param argc the count of arguments in \a argv
163 :     * \param argv the array of command-line arguments.
164 :     */
165 :     int main(int argc, const char **argv)
166 :     {
167 :     glfwSetErrorCallback (error);
168 :    
169 :     glfwInit ();
170 :    
171 :     view = view_createView(WIDTH,HEIGHT);
172 :    
173 :     dProg.particles = NULL;
174 :    
175 :     // Check the GLFW version
176 :     {
177 :     int major;
178 :     glfwGetVersion (&major, NULL, NULL);
179 :     if (major < 3) {
180 :     fprintf(stderr,"the is2d demo requires GLFW 3.0 or later\n\n");
181 :     exit (EXIT_FAILURE);
182 :     }
183 :     }
184 :    
185 :     glfwWindowHint (GLFW_RESIZABLE, GL_TRUE);
186 :     glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, 4);
187 :     glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, 1);
188 :     glfwWindowHint (GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
189 :     glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
190 :    
191 :     GLFWwindow *window = glfwCreateWindow(view->width, view->height, "iso2d Using Spatial Communication", NULL, NULL);
192 :     if (window == NULL)
193 :     exit (EXIT_FAILURE);
194 :    
195 :     glfwMakeContextCurrent (window);
196 :    
197 :     setViewPort(window);
198 :    
199 :     // Check the OpenGL version
200 :     {
201 :     GLint major, minor;
202 :     glGetIntegerv (GL_MAJOR_VERSION, &major);
203 :     glGetIntegerv (GL_MINOR_VERSION, &minor);
204 :     if ((major < 3) || ((major == 3) && (minor < 2))) {
205 :     fprintf(stderr,"the iso2d demo requires OpenGL 3.2 or later; found %d.%d\n", major,minor);
206 :     exit (EXIT_FAILURE);
207 :     }
208 :     }
209 :    
210 :     // NOTE: the shaders must be initialized after a GL context is in place.
211 :     view_init(view,"shaders/shader.vert","shaders/shader.frag");
212 :    
213 :    
214 :     // set up callbacks
215 :     //glfwSetWindowRefreshCallback (window, display);
216 :     // glfwSetWindowSizeCallback (window, Reshape);
217 :     // glfwSetWindowIconifyCallback (window, Visible);
218 :     // glfwSetCharCallback (window, key);
219 :     glfwSetKeyCallback(window, key_callback);
220 :    
221 :     //Initialize Diderot program
222 :     diderot_init(window);
223 :    
224 :     while (! glfwWindowShouldClose(window)) {
225 :     step(window);
226 :     display (window);
227 :     glfwPollEvents ();
228 :     // glfwWaitEvents();
229 :     }
230 :    
231 :     glfwTerminate ();
232 :    
233 :     return EXIT_SUCCESS;
234 :    
235 :     } /* end of main */

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0