└── rsm
├── GL.sln
└── GL
├── GL.vcxproj
├── GL.vcxproj.filters
├── GL.vcxproj.user
├── SDL.dll
├── glew32.dll
├── main.cpp
├── matrix.h
├── primitive.h
├── rt.h
├── shader.cpp
├── shader.h
└── shader
├── blur.vs
├── blurx.fs
├── blury.fs
├── gi.fs
├── gi.vs
├── light.fs
├── light.vs
├── post.fs
├── post.vs
├── shader.fs
├── shader.vs
├── vpl.fs
├── vpl.vs
├── vpl_normal.fs
├── vpl_normal.vs
├── vpl_pos.fs
└── vpl_pos.vs
/rsm/GL.sln:
--------------------------------------------------------------------------------
1 |
2 | Microsoft Visual Studio Solution File, Format Version 11.00
3 | # Visual Studio 2010
4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GL", "GL\GL.vcxproj", "{A298D3D9-7A03-4BB3-A4CE-CB1B9951EE14}"
5 | EndProject
6 | Global
7 | GlobalSection(SolutionConfigurationPlatforms) = preSolution
8 | Debug|Win32 = Debug|Win32
9 | Release|Win32 = Release|Win32
10 | EndGlobalSection
11 | GlobalSection(ProjectConfigurationPlatforms) = postSolution
12 | {A298D3D9-7A03-4BB3-A4CE-CB1B9951EE14}.Debug|Win32.ActiveCfg = Debug|Win32
13 | {A298D3D9-7A03-4BB3-A4CE-CB1B9951EE14}.Debug|Win32.Build.0 = Debug|Win32
14 | {A298D3D9-7A03-4BB3-A4CE-CB1B9951EE14}.Release|Win32.ActiveCfg = Release|Win32
15 | {A298D3D9-7A03-4BB3-A4CE-CB1B9951EE14}.Release|Win32.Build.0 = Release|Win32
16 | EndGlobalSection
17 | GlobalSection(SolutionProperties) = preSolution
18 | HideSolutionNode = FALSE
19 | EndGlobalSection
20 | EndGlobal
21 |
--------------------------------------------------------------------------------
/rsm/GL/GL.vcxproj:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | Debug
6 | Win32
7 |
8 |
9 | Release
10 | Win32
11 |
12 |
13 |
14 | {A298D3D9-7A03-4BB3-A4CE-CB1B9951EE14}
15 | Win32Proj
16 | GL
17 |
18 |
19 |
20 | Application
21 | true
22 | Unicode
23 |
24 |
25 | Application
26 | false
27 | true
28 | Unicode
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 | true
42 |
43 |
44 | false
45 |
46 |
47 |
48 |
49 |
50 | Level3
51 | Disabled
52 | WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)
53 | $(SDL)/include;$(GLEW)/include;
54 |
55 |
56 | Console
57 | true
58 | opengl32.lib;glu32.lib;winmm.lib;$(SDL)/lib/x86/SDLmain.lib;$(SDL)/lib/x86/SDL.lib;$(GLEW)/lib/glew32.lib;$(GLEW)/lib/glew32mx.lib;%(AdditionalDependencies)
59 |
60 |
61 |
62 |
63 | Level3
64 |
65 |
66 | MaxSpeed
67 | true
68 | true
69 | WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)
70 | $(SDL)/include;$(GLEW)/include;
71 |
72 |
73 | Console
74 | true
75 | true
76 | true
77 | opengl32.lib;glu32.lib;winmm.lib;$(SDL)/lib/x86/SDLmain.lib;$(SDL)/lib/x86/SDL.lib;$(GLEW)/lib/glew32.lib;$(GLEW)/lib/glew32mx.lib;%(AdditionalDependencies)
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
--------------------------------------------------------------------------------
/rsm/GL/GL.vcxproj.filters:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF}
6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx
7 |
8 |
9 | {93995380-89BD-4b04-88EB-625FBE52EBFB}
10 | h;hpp;hxx;hm;inl;inc;xsd
11 |
12 |
13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01}
14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms
15 |
16 |
17 | {cc7cc317-e694-4005-9253-e00b7e9190b5}
18 |
19 |
20 |
21 |
22 | ソース ファイル
23 |
24 |
25 | ソース ファイル\Lib
26 |
27 |
28 |
29 |
30 | ソース ファイル\Lib
31 |
32 |
33 | ソース ファイル\Lib
34 |
35 |
36 | ソース ファイル\Lib
37 |
38 |
39 | ソース ファイル\Lib
40 |
41 |
42 |
--------------------------------------------------------------------------------
/rsm/GL/GL.vcxproj.user:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/rsm/GL/SDL.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/githole/rsm/7fb1229ddd2586a7d031400c2f33b3bd7d613a1c/rsm/GL/SDL.dll
--------------------------------------------------------------------------------
/rsm/GL/glew32.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/githole/rsm/7fb1229ddd2586a7d031400c2f33b3bd7d613a1c/rsm/GL/glew32.dll
--------------------------------------------------------------------------------
/rsm/GL/main.cpp:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 | #include
5 | #include
6 |
7 | #include "shader.h"
8 | #include "rt.h"
9 | #include "matrix.h"
10 | #include "primitive.h"
11 |
12 | static Shader shader;
13 | static Shader lightShader;
14 | static Shader postShader;
15 | static Shader vplShader;
16 | static Shader vpl_normalShader;
17 | static Shader vpl_posShader;
18 | static Shader giShader;
19 | static Shader blurXShader;
20 | static Shader blurYShader;
21 |
22 |
23 | static RenderTarget *giRT;
24 | static RenderTarget *lightRT;
25 | static RenderTarget *cameraRT;
26 |
27 | static RenderTarget *vplRT;
28 | static RenderTarget *vplPosRT;
29 | static RenderTarget *vplNormalRT;
30 |
31 | static RenderTarget *blurRT;
32 |
33 | static float myAngle, sunAngle;
34 | const int CameraTexSize = 1024;
35 | const int ShadowMapSize = 1024;
36 | const int vplTexSize = 512;
37 | const int giTexSize = 256;
38 | const int blurTexSize = 256;
39 |
40 |
41 | static int windowWidth = 1280;
42 | static int windowHeight = 720;
43 |
44 | void CompileShader() {
45 | shader.CompileFromFile("./shader/shader.fs", "./shader/shader.vs");
46 | lightShader.CompileFromFile("./shader/light.fs", "./shader/light.vs");
47 | postShader.CompileFromFile("./shader/post.fs", "./shader/post.vs");
48 | vplShader.CompileFromFile("./shader/vpl.fs", "./shader/vpl.vs");
49 | vpl_normalShader.CompileFromFile("./shader/vpl_normal.fs", "./shader/vpl_normal.vs");
50 | vpl_posShader.CompileFromFile("./shader/vpl_pos.fs", "./shader/vpl_pos.vs");
51 | giShader.CompileFromFile("./shader/gi.fs", "./shader/gi.vs");
52 | blurXShader.CompileFromFile("./shader/blurx.fs", "./shader/blur.vs");
53 | blurYShader.CompileFromFile("./shader/blury.fs", "./shader/blur.vs");
54 | }
55 |
56 | int ProcessSDLEvents() {
57 | SDL_Event eve;
58 | while (SDL_PollEvent(&eve)) {
59 | switch(eve.type) {
60 | case SDL_KEYDOWN:
61 | {
62 | Uint16 ch = eve.key.keysym.unicode;
63 | SDLKey key = isprint(ch) ? (SDLKey)ch : eve.key.keysym.sym;
64 |
65 | if (eve.key.keysym.sym == SDLK_F5) {
66 | CompileShader();
67 | }
68 | if (eve.key.keysym.sym == SDLK_LEFT)
69 | myAngle -= 0.01f;
70 | if (eve.key.keysym.sym == SDLK_RIGHT)
71 | myAngle += 0.01f;
72 |
73 | if (eve.key.keysym.sym == SDLK_a)
74 | sunAngle -= 0.01f;
75 | if (eve.key.keysym.sym == SDLK_s)
76 | sunAngle += 0.01f;
77 |
78 | if (eve.key.keysym.sym == SDLK_ESCAPE)
79 | return -1;
80 | }
81 | break;
82 |
83 | case SDL_QUIT:
84 | return -1;
85 | }
86 | }
87 | return 0;
88 | }
89 |
90 |
91 | int Initialize(const int width, const int height, const int SDLflags) {
92 | const SDL_VideoInfo* info = NULL;
93 |
94 | if (SDL_Init(SDL_INIT_VIDEO) < 0) {
95 | std::cerr << SDL_GetError() << std::endl;
96 | return -1;
97 | }
98 | std::cerr << "SDL_Init succeeded" << std::endl;
99 |
100 | SDL_WM_SetCaption("test", NULL);
101 |
102 | info = SDL_GetVideoInfo( );
103 |
104 | if (!info) {
105 | std::cerr << SDL_GetError() << std::endl;
106 | return -1;
107 | }
108 | std::cerr << "SDL_GetVideoInfo succeeded" << std::endl;
109 |
110 | const int bpp = info->vfmt->BitsPerPixel;
111 |
112 | SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
113 | SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
114 | SDL_EnableUNICODE(true);
115 | SDL_EnableKeyRepeat(25, 1);
116 |
117 | if (SDL_SetVideoMode(width, height, bpp, SDLflags) == 0) {
118 | std::cerr << SDL_GetError() << std::endl;
119 | return -1;
120 | }
121 | std::cerr << "SDL_SetVideoMode succeeded" << std::endl;
122 |
123 | if (glewInit() != GLEW_OK) {
124 | std::cerr << "Error: glewInit()" << std::endl;
125 | return -1;
126 | }
127 | std::cerr << "glewInit succeeded" << std::endl;
128 |
129 | // shader
130 | CompileShader();
131 |
132 | // シャドウマップ
133 | lightRT = new RenderTarget(ShadowMapSize, GL_CLAMP_TO_BORDER);
134 |
135 | // カメラテクスチャ
136 | cameraRT = new RenderTarget(CameraTexSize, GL_CLAMP_TO_EDGE, GL_LINEAR, GL_RGBA, GL_UNSIGNED_BYTE);
137 |
138 | // VPL
139 | vplRT = new RenderTarget(vplTexSize, GL_CLAMP_TO_EDGE, GL_NEAREST);
140 |
141 | // VPL法線
142 | vplNormalRT = new RenderTarget(vplTexSize, GL_CLAMP_TO_EDGE, GL_NEAREST);
143 |
144 | // VPL位置
145 | vplPosRT = new RenderTarget(vplTexSize, GL_CLAMP_TO_EDGE, GL_NEAREST);
146 |
147 | // GI
148 | giRT = new RenderTarget(giTexSize);
149 |
150 | // BluredGI
151 | blurRT = new RenderTarget(blurTexSize);
152 |
153 |
154 | glBindTexture(GL_TEXTURE_2D, 0);
155 | glBindRenderbuffer(GL_RENDERBUFFER, 0);
156 | glBindFramebuffer(GL_FRAMEBUFFER, 0);
157 | return 0;
158 | }
159 |
160 |
161 | void SetMatrix(Shader& s) {
162 | // CameraProjection
163 | s.SetUniformMatrix4x4("uCamProj", Matrix::PerspectiveMatrix(45.0f, (float)windowWidth / windowHeight, 0.1f, 100.0f).m);
164 |
165 | // CameraView
166 | s.SetUniformMatrix4x4("uCamView",
167 | Matrix::LookAt(5.0f * sin(myAngle), 5.0f, 5.0f * cos(myAngle),
168 | 0.0f, 0.0f, 0.0f,
169 | 0.0f, 1.0f, 0.0f).m);
170 | // LightProjection
171 | s.SetUniformMatrix4x4("uLightProj", Matrix::OrthoMatrix(-5.0f, 5.0f, -5.0f, 5.0f, 0.1f, 100.0f).m);
172 |
173 | // LightView
174 | Matrix uLightView = Matrix::LookAt(12.0f * sin(sunAngle), 16.0f, 10.0f * cos(sunAngle),
175 | 0.0f, 0.0f, 0.0f,
176 | 0.0f, 1.0f, 0.0f);
177 | s.SetUniformMatrix4x4("uLightView", uLightView.m);
178 |
179 | GLfloat invm[16];
180 | GLfloat transm[16];
181 | Matrix::inverse(uLightView.m, invm);
182 | Matrix::transpose(invm, transm);
183 | s.SetUniformMatrix4x4("uLightNormalMatrix", transm);
184 | }
185 |
186 |
187 | void DrawObjects(Shader &s) {
188 | // 平面描画
189 | s.SetUniformMatrix4x4("uModel", Matrix().m);
190 | glColor4f(0.7f, 0.7f, 0.7f, 1.0f);
191 | DrawPlane(20.0f);
192 |
193 | // 立方体
194 | // ModelMatrix
195 | s.SetUniformMatrix4x4("uModel", Matrix().m);
196 | glColor4f(1, 0.4f, 0.5f, 1.0f);
197 | DrawCube(1.0f, 1.0f, 1.0f);
198 |
199 | // ModelMatrix
200 | s.SetUniformMatrix4x4("uModel", Matrix::TranslateMatrix(0.85f, 0.7f, 0.3f).m);
201 | glColor4f(0.98f, 0.98f, 0.98f, 1.0f);
202 | DrawCube(1.0f, 1.0f, 1.0f);
203 |
204 | // ModelMatrix
205 | s.SetUniformMatrix4x4("uModel", Matrix::TranslateMatrix(-0.3f, -0.5f, 2.5f).m);
206 | glColor4f(0.2f, 0.3f, 1, 1.0f);
207 | DrawCube(1.0f, 1.0f, 1.0f);
208 |
209 | // ModelMatrix
210 | s.SetUniformMatrix4x4("uModel", Matrix::TranslateMatrix(2.0f, 0.6f, 1.5f).m);
211 | glColor4f(0.2f, 1.0f, 0.3f, 1.0f);
212 | DrawCube(1.0f, 1.0f, 1.0f);
213 |
214 | // ModelMatrix
215 | s.SetUniformMatrix4x4("uModel", Matrix::TranslateMatrix(-1.85f, -0.5f, -1.3f).m);
216 | glColor4f(0.98f, 0.98f, 0.98f, 1.0f);
217 | DrawCube(1.0f, 1.0f, 1.0f);
218 | }
219 |
220 | static float lightIntensity[4] = {1.5f, 1.4f, 1.2f, 1.0f};
221 | static float ambient[4] = {0.7f, 0.8f, 1.1f, 1.0f};
222 |
223 | void RenderObject() {
224 | cameraRT->Bind();
225 |
226 | glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
227 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
228 |
229 | glEnable(GL_DEPTH_TEST);
230 |
231 | shader.Bind();
232 | shader.SetUniform("resolution", (float)cameraRT->Size(), (float)cameraRT->Size());
233 | shader.SetUniform("uAmbient", ambient[0], ambient[1], ambient[2], ambient[3]);
234 | shader.SetUniform("uLightIntensity", lightIntensity[0], lightIntensity[1], lightIntensity[2], lightIntensity[3]);
235 |
236 | glActiveTexture(GL_TEXTURE0);
237 | glBindTexture(GL_TEXTURE_2D, lightRT->Texture());
238 | shader.SetUniform("shadowMap", (int)0);
239 |
240 |
241 | glActiveTexture(GL_TEXTURE1);
242 | glBindTexture(GL_TEXTURE_2D, giRT->Texture());
243 | shader.SetUniform("giTexture", (int)1);
244 |
245 |
246 | SetMatrix(shader);
247 | DrawObjects(shader);
248 |
249 | shader.Unbind();
250 |
251 | // テクスチャ描画
252 | const float aspect = (float)windowWidth / windowHeight;
253 | glActiveTexture(GL_TEXTURE0);
254 | glBindTexture(GL_TEXTURE_2D, lightRT->Texture());
255 | DrawTexture(0.9f, -0.8f, 0.1f, 0.1f * aspect);
256 |
257 | glBindTexture(GL_TEXTURE_2D, vplRT->Texture());
258 | DrawTexture(0.6f, -0.8f, 0.1f, 0.1f * aspect);
259 |
260 | glBindTexture(GL_TEXTURE_2D, vplPosRT->Texture());
261 | DrawTexture(0.3f, -0.8f, 0.1f, 0.1f * aspect);
262 |
263 | glBindTexture(GL_TEXTURE_2D, vplNormalRT->Texture());
264 | DrawTexture(0.0f, -0.8f, 0.1f, 0.1f * aspect);
265 |
266 | glBindTexture(GL_TEXTURE_2D, giRT->Texture());
267 | DrawTexture(-0.3f, -0.8f, 0.1f, 0.1f * aspect);
268 | }
269 |
270 | void RenderVPL() {
271 | vplRT->Bind();
272 |
273 | glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
274 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
275 |
276 | glEnable(GL_DEPTH_TEST);
277 |
278 | vplShader.Bind();
279 |
280 | vplShader.SetUniform("uLightIntensity", lightIntensity[0], lightIntensity[1], lightIntensity[2], lightIntensity[3]);
281 |
282 | SetMatrix(vplShader);
283 | DrawObjects(vplShader);
284 |
285 | vplShader.Unbind();
286 | }
287 |
288 |
289 | void RenderVPLPos() {
290 | vplPosRT->Bind();
291 |
292 | glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
293 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
294 |
295 | glEnable(GL_DEPTH_TEST);
296 | vpl_posShader.Bind();
297 |
298 | SetMatrix(vpl_posShader);
299 | DrawObjects(vpl_posShader);
300 |
301 | vpl_posShader.Unbind();
302 | }
303 |
304 | void RenderVPLNormal() {
305 | vplNormalRT->Bind();
306 |
307 | glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
308 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
309 |
310 | glEnable(GL_DEPTH_TEST);
311 | vpl_normalShader.Bind();
312 |
313 | SetMatrix(vpl_normalShader);
314 | DrawObjects(vpl_normalShader);
315 |
316 | vpl_normalShader.Unbind();
317 | }
318 |
319 | void RenderGI() {
320 | giRT->Bind();
321 |
322 | glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
323 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
324 |
325 | glEnable(GL_DEPTH_TEST);
326 |
327 | giShader.Bind();
328 |
329 | glActiveTexture(GL_TEXTURE1);
330 | glBindTexture(GL_TEXTURE_2D, vplRT->Texture());
331 | giShader.SetUniform("vplTexture", (int)1);
332 | glActiveTexture(GL_TEXTURE2);
333 | glBindTexture(GL_TEXTURE_2D, vplPosRT->Texture());
334 | giShader.SetUniform("vplPosTexture", (int)2);
335 | glActiveTexture(GL_TEXTURE3);
336 | glBindTexture(GL_TEXTURE_2D, vplNormalRT->Texture());
337 | giShader.SetUniform("vplNormalTexture", (int)3);
338 |
339 | SetMatrix(giShader);
340 | DrawObjects(giShader);
341 |
342 | giShader.Unbind();
343 | }
344 |
345 | void RenderShadowmap() {
346 | lightRT->Bind();
347 |
348 | glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
349 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
350 |
351 | glEnable(GL_DEPTH_TEST);
352 |
353 | lightShader.Bind();
354 |
355 | SetMatrix(lightShader);
356 | DrawObjects(lightShader);
357 |
358 | lightShader.Unbind();
359 | }
360 |
361 | void BlurGI(RenderTarget *rt) {
362 | blurRT->Bind();
363 | glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
364 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
365 |
366 | blurYShader.Bind();
367 | blurYShader.SetUniform("resolution", (float)blurRT->Size(), (float)blurRT->Size());
368 | // テクスチャ描画
369 | glActiveTexture(GL_TEXTURE0);
370 | glBindTexture(GL_TEXTURE_2D, rt->Texture());
371 | blurYShader.SetUniform("texture", (int)0);
372 | DrawTexture(0, 0, 1, 1);
373 | blurYShader.Unbind();
374 |
375 |
376 | rt->Bind();
377 | glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
378 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
379 | blurXShader.Bind();
380 | blurXShader.SetUniform("resolution", (float)rt->Size(), (float)rt->Size());
381 | // テクスチャ描画
382 | glActiveTexture(GL_TEXTURE0);
383 | glBindTexture(GL_TEXTURE_2D, blurRT->Texture());
384 | blurXShader.SetUniform("texture", (int)0);
385 | DrawTexture(0, 0, 1, 1);
386 |
387 | blurXShader.Unbind();
388 |
389 | }
390 |
391 | int Render() {
392 | RenderVPL();
393 | RenderVPLPos();
394 | RenderVPLNormal();
395 | RenderGI();
396 | for (int i = 0; i < 6; i ++)
397 | BlurGI(giRT);
398 |
399 | RenderShadowmap();
400 | RenderObject();
401 |
402 |
403 | glViewport(0, 0, windowWidth, windowHeight);
404 | glBindFramebuffer(GL_FRAMEBUFFER, 0);
405 | glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
406 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
407 | postShader.Bind();
408 | // テクスチャ描画
409 | glActiveTexture(GL_TEXTURE0);
410 | glBindTexture(GL_TEXTURE_2D, cameraRT->Texture());
411 | postShader.SetUniform("texture", (int)0);
412 | postShader.SetUniform("resolution", (float)windowWidth, (float)windowHeight);
413 | postShader.SetUniform("time", (float)SDL_GetTicks());
414 | DrawTexture(0, 0, 1, 1);
415 | postShader.Unbind();
416 |
417 | SDL_GL_SwapBuffers();
418 | return 0;
419 | }
420 |
421 | int main(int argc, char** argv) {
422 | int flags = SDL_OPENGL;
423 |
424 | if (argc >= 2) {
425 | if (strcmp(argv[1], "-f") == 0) {
426 | flags = SDL_OPENGL | SDL_FULLSCREEN ;
427 | }
428 | }
429 | if (argc >= 4) {
430 | windowWidth = atoi(argv[2]);
431 | windowHeight = atoi(argv[3]);
432 | }
433 |
434 | if (Initialize(windowWidth, windowHeight, flags) < 0)
435 | return 0;
436 |
437 | while (1) {
438 | if (ProcessSDLEvents() < 0)
439 | break;
440 |
441 | int now = SDL_GetTicks();
442 | Render();
443 | int tm = SDL_GetTicks() - now;
444 | char buf[256];
445 | sprintf(buf, "%d", tm);
446 | SDL_WM_SetCaption(buf, NULL);
447 | }
448 |
449 | return 0;
450 | }
451 |
--------------------------------------------------------------------------------
/rsm/GL/matrix.h:
--------------------------------------------------------------------------------
1 | #ifndef _MATRIX_H_
2 | #define _MATRIX_H_
3 |
4 |
5 | class Matrix {
6 | private:
7 | public:
8 | float m[16];
9 |
10 | inline void Set(const float m00, const float m01, const float m02, const float m03,
11 | const float m10, const float m11, const float m12, const float m13,
12 | const float m20, const float m21, const float m22, const float m23,
13 | const float m30, const float m31, const float m32, const float m33) {
14 | m[0] = m00; m[1] = m01; m[2] = m02; m[3] = m03;
15 | m[4] = m10; m[5] = m11; m[6] = m12; m[7] = m13;
16 | m[8] = m20; m[9] = m21; m[10] = m22; m[11] = m23;
17 | m[12] = m30; m[13] = m31; m[14] = m32; m[15] = m33;
18 | }
19 |
20 | Matrix() {
21 | Set(1.0f, 0.0f, 0.0f, 0.0f,
22 | 0.0f, 1.0f, 0.0f, 0.0f,
23 | 0.0f, 0.0f, 1.0f, 0.0f,
24 | 0.0f, 0.0f, 0.0f, 1.0f);
25 | }
26 |
27 | static Matrix TranslateMatrix(const float x, const float y, const float z) {
28 | Matrix m;
29 | m.Set(1.0f, 0.0f, 0.0f, 0,
30 | 0.0f, 1.0f, 0.0f, 0,
31 | 0.0f, 0.0f, 1.0f, 0,
32 | x, y, z, 1.0f);
33 | return m;
34 | }
35 |
36 | static Matrix PerspectiveMatrix(const float fovy, const float aspect, const float znear, const float zfar) {
37 | const float radian = 2.0f * (3.1415926536f) * fovy/360.0f;
38 | const float t = (float)(1.0 / tan(radian/2));
39 | Matrix m;
40 | m.Set(t/aspect, 0, 0, 0,
41 | 0, t, 0, 0,
42 | 0, 0, (zfar + znear) / (znear - zfar), -1,
43 | 0, 0, (2 * zfar * znear) / (znear - zfar), 0);
44 | return m;
45 | }
46 |
47 | static Matrix OrthoMatrix(const float left, const float right, const float bottom, const float top, const float znear, const float zfar) {
48 | const float tx = -(right + left) / (right - left);
49 | const float ty = -(top + bottom) / (top - bottom);
50 | const float tz = -(zfar + znear) / (zfar - znear);
51 | Matrix m;
52 | m.Set(2.0f / (right - left), 0, 0, 0,
53 | 0, 2.0f / (top - bottom), 0, 0,
54 | 0, 0, -2.0f / (zfar - znear), 0,
55 | tx, ty, tz, 1.0f);
56 | return m;
57 | }
58 |
59 | private:
60 | static void cross(const float a[3], const float b[3], float out[3]) {
61 | out[0] = a[1] * b[2] - a[2] * b[1];
62 | out[1] = a[2] * b[0] - a[0] * b[2];
63 | out[2] = a[0] * b[1] - a[1] * b[0];
64 | }
65 | static void normalize(float* v){
66 | float m = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
67 | m = 1.0f / m;
68 | v[0] *= m;
69 | v[1] *= m;
70 | v[2] *= m;
71 | }
72 |
73 | static void multiplication(const GLfloat src1[16], const GLfloat src2[16], GLfloat dst[16])
74 | {
75 | for (int y = 0; y < 4; y++) {
76 | for (int x = 0; x < 4; x++) {
77 | dst[y*4 + x] = src2[y*4] * src1[x] +
78 | src2[y*4 + 1] * src1[x + 4] +
79 | src2[y*4 + 2] * src1[x + 8] +
80 | src2[y*4 + 3] * src1[x + 12];
81 | }
82 | }
83 | }
84 |
85 | public:
86 | static void transpose(const GLfloat m[16], GLfloat t[16]) {
87 | for (int y = 0; y < 4; y++) {
88 | for (int x = 0; x < 4; x++) {
89 | t[y*4 + x] = m[x * 4 + y];
90 | }
91 | }
92 | }
93 |
94 | // http://stackoverflow.com/questions/1148309/inverting-a-4x4-matrix
95 | static bool inverse(const GLfloat m[16], GLfloat invOut[16])
96 | {
97 | GLfloat inv[16], det;
98 | int i;
99 |
100 | inv[0] = m[5] * m[10] * m[15] -
101 | m[5] * m[11] * m[14] -
102 | m[9] * m[6] * m[15] +
103 | m[9] * m[7] * m[14] +
104 | m[13] * m[6] * m[11] -
105 | m[13] * m[7] * m[10];
106 |
107 | inv[4] = -m[4] * m[10] * m[15] +
108 | m[4] * m[11] * m[14] +
109 | m[8] * m[6] * m[15] -
110 | m[8] * m[7] * m[14] -
111 | m[12] * m[6] * m[11] +
112 | m[12] * m[7] * m[10];
113 |
114 | inv[8] = m[4] * m[9] * m[15] -
115 | m[4] * m[11] * m[13] -
116 | m[8] * m[5] * m[15] +
117 | m[8] * m[7] * m[13] +
118 | m[12] * m[5] * m[11] -
119 | m[12] * m[7] * m[9];
120 |
121 | inv[12] = -m[4] * m[9] * m[14] +
122 | m[4] * m[10] * m[13] +
123 | m[8] * m[5] * m[14] -
124 | m[8] * m[6] * m[13] -
125 | m[12] * m[5] * m[10] +
126 | m[12] * m[6] * m[9];
127 |
128 | inv[1] = -m[1] * m[10] * m[15] +
129 | m[1] * m[11] * m[14] +
130 | m[9] * m[2] * m[15] -
131 | m[9] * m[3] * m[14] -
132 | m[13] * m[2] * m[11] +
133 | m[13] * m[3] * m[10];
134 |
135 | inv[5] = m[0] * m[10] * m[15] -
136 | m[0] * m[11] * m[14] -
137 | m[8] * m[2] * m[15] +
138 | m[8] * m[3] * m[14] +
139 | m[12] * m[2] * m[11] -
140 | m[12] * m[3] * m[10];
141 |
142 | inv[9] = -m[0] * m[9] * m[15] +
143 | m[0] * m[11] * m[13] +
144 | m[8] * m[1] * m[15] -
145 | m[8] * m[3] * m[13] -
146 | m[12] * m[1] * m[11] +
147 | m[12] * m[3] * m[9];
148 |
149 | inv[13] = m[0] * m[9] * m[14] -
150 | m[0] * m[10] * m[13] -
151 | m[8] * m[1] * m[14] +
152 | m[8] * m[2] * m[13] +
153 | m[12] * m[1] * m[10] -
154 | m[12] * m[2] * m[9];
155 |
156 | inv[2] = m[1] * m[6] * m[15] -
157 | m[1] * m[7] * m[14] -
158 | m[5] * m[2] * m[15] +
159 | m[5] * m[3] * m[14] +
160 | m[13] * m[2] * m[7] -
161 | m[13] * m[3] * m[6];
162 |
163 | inv[6] = -m[0] * m[6] * m[15] +
164 | m[0] * m[7] * m[14] +
165 | m[4] * m[2] * m[15] -
166 | m[4] * m[3] * m[14] -
167 | m[12] * m[2] * m[7] +
168 | m[12] * m[3] * m[6];
169 |
170 | inv[10] = m[0] * m[5] * m[15] -
171 | m[0] * m[7] * m[13] -
172 | m[4] * m[1] * m[15] +
173 | m[4] * m[3] * m[13] +
174 | m[12] * m[1] * m[7] -
175 | m[12] * m[3] * m[5];
176 |
177 | inv[14] = -m[0] * m[5] * m[14] +
178 | m[0] * m[6] * m[13] +
179 | m[4] * m[1] * m[14] -
180 | m[4] * m[2] * m[13] -
181 | m[12] * m[1] * m[6] +
182 | m[12] * m[2] * m[5];
183 |
184 | inv[3] = -m[1] * m[6] * m[11] +
185 | m[1] * m[7] * m[10] +
186 | m[5] * m[2] * m[11] -
187 | m[5] * m[3] * m[10] -
188 | m[9] * m[2] * m[7] +
189 | m[9] * m[3] * m[6];
190 |
191 | inv[7] = m[0] * m[6] * m[11] -
192 | m[0] * m[7] * m[10] -
193 | m[4] * m[2] * m[11] +
194 | m[4] * m[3] * m[10] +
195 | m[8] * m[2] * m[7] -
196 | m[8] * m[3] * m[6];
197 |
198 | inv[11] = -m[0] * m[5] * m[11] +
199 | m[0] * m[7] * m[9] +
200 | m[4] * m[1] * m[11] -
201 | m[4] * m[3] * m[9] -
202 | m[8] * m[1] * m[7] +
203 | m[8] * m[3] * m[5];
204 |
205 | inv[15] = m[0] * m[5] * m[10] -
206 | m[0] * m[6] * m[9] -
207 | m[4] * m[1] * m[10] +
208 | m[4] * m[2] * m[9] +
209 | m[8] * m[1] * m[6] -
210 | m[8] * m[2] * m[5];
211 |
212 | det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12];
213 |
214 | if (det == 0)
215 | return false;
216 |
217 | det = 1.0 / det;
218 |
219 | for (i = 0; i < 16; i++)
220 | invOut[i] = inv[i] * det;
221 |
222 | return true;
223 | }
224 | static Matrix LookAt(const float eyex, const float eyey, const float eyez, const float centerx, const float centery, const float centerz, const float upx, const float upy, const float upz) {
225 | float f[3] = {centerx - eyex, centery - eyey, centerz - eyez};
226 | normalize(f);
227 | float UP[3] = {upx, upy, upz};
228 | normalize(UP);
229 | float s[3];
230 | cross(f, UP, s);
231 | float u[3];
232 | normalize(s);
233 | cross(s, f, u);
234 |
235 | Matrix m1;
236 | m1.Set(s[0], u[0], -f[0], 0,
237 | s[1], u[1], -f[1], 0,
238 | s[2], u[2], -f[2], 0,
239 | 0, 0, 0, 1);
240 |
241 | Matrix m2;
242 | m2.Set( 1,0,0,0,
243 | 0,1,0,0,
244 | 0,0,1,0,
245 | -eyex,-eyey,-eyez,1);
246 |
247 | Matrix m3;
248 | multiplication(m1.m, m2.m, m3.m);
249 | return m3;
250 | }
251 |
252 |
253 | };
254 |
255 | #endif
--------------------------------------------------------------------------------
/rsm/GL/primitive.h:
--------------------------------------------------------------------------------
1 | #ifndef _PRIMITIVE_H_
2 | #define _PRIMITIVE_H_
3 |
4 | #include
5 | #include
6 | #include
7 | #include
8 |
9 |
10 | void DrawTexture(const float x, const float y, const float w, const float h) {
11 | glMatrixMode(GL_PROJECTION);
12 | glLoadIdentity();
13 | glMatrixMode(GL_MODELVIEW);
14 | glLoadIdentity();
15 |
16 | glEnable(GL_TEXTURE_2D);
17 |
18 | glColor4f(1, 1, 1, 1);
19 | glBegin(GL_TRIANGLE_FAN);
20 | glTexCoord2f(1.0f, 1.0f);
21 | glVertex3f(x+w, y+h, 0);
22 | glTexCoord2f(0.0f, 1.0f);
23 | glVertex3f(x-w, y+h, 0);
24 | glTexCoord2f(0.0f, 0.0f);
25 | glVertex3f(x-w, y-h, 0);
26 | glTexCoord2f(1.0f, 0.0f);
27 | glVertex3f(x+w, y-h, 0);
28 | glEnd();
29 | }
30 |
31 | void DrawPlane(const GLfloat size) {
32 | static GLfloat vertices[4][3] = {
33 | {-size, 0.0f, size},
34 | { size, 0.0f, size},
35 | { size, 0.0f, -size},
36 | {-size, 0.0f, -size},
37 | };
38 |
39 | glBegin(GL_TRIANGLE_FAN);
40 | glNormal3f(0.0, 1.0, 0.0);
41 | glVertex3fv(vertices[0]);
42 | glVertex3fv(vertices[1]);
43 | glVertex3fv(vertices[2]);
44 | glVertex3fv(vertices[3]);
45 | glEnd();
46 | }
47 |
48 | void DrawCube(const GLfloat xsize, const GLfloat ysize, const GLfloat zsize) {
49 | const GLfloat x = xsize;
50 | const GLfloat y = ysize;
51 | const GLfloat z = zsize;
52 | GLfloat vertices[8][3] = {
53 | { x, y, z},
54 | { x, y,-z},
55 | {-x, y,-z},
56 | {-x, y, z},
57 | { x,-y, z},
58 | { x,-y,-z},
59 | {-x,-y,-z},
60 | {-x,-y, z},
61 | };
62 |
63 | // +Y
64 | glBegin(GL_TRIANGLE_FAN);
65 | glNormal3f(0.0, 1.0, 0.0);
66 | glVertex3fv(vertices[0]);
67 | glVertex3fv(vertices[1]);
68 | glVertex3fv(vertices[2]);
69 | glVertex3fv(vertices[3]);
70 | glEnd();
71 |
72 | // -Y
73 | glBegin(GL_TRIANGLE_FAN);
74 | glNormal3f(0.0,-1.0, 0.0);
75 | glVertex3fv(vertices[4]);
76 | glVertex3fv(vertices[7]);
77 | glVertex3fv(vertices[6]);
78 | glVertex3fv(vertices[5]);
79 | glEnd();
80 |
81 | // +X
82 | glBegin(GL_TRIANGLE_FAN);
83 | glNormal3f(1.0,0.0, 0.0);
84 | glVertex3fv(vertices[0]);
85 | glVertex3fv(vertices[4]);
86 | glVertex3fv(vertices[5]);
87 | glVertex3fv(vertices[1]);
88 | glEnd();
89 |
90 | // -X
91 | glBegin(GL_TRIANGLE_FAN);
92 | glNormal3f(-1.0,0.0, 0.0);
93 | glVertex3fv(vertices[2]);
94 | glVertex3fv(vertices[6]);
95 | glVertex3fv(vertices[7]);
96 | glVertex3fv(vertices[3]);
97 | glEnd();
98 |
99 | // +Z
100 | glBegin(GL_TRIANGLE_FAN);
101 | glNormal3f(0.0,0.0,1.0);
102 | glVertex3fv(vertices[0]);
103 | glVertex3fv(vertices[3]);
104 | glVertex3fv(vertices[7]);
105 | glVertex3fv(vertices[4]);
106 | glEnd();
107 |
108 | // -Z
109 | glBegin(GL_TRIANGLE_FAN);
110 | glNormal3f(0.0,0.0,-1.0);
111 | glVertex3fv(vertices[1]);
112 | glVertex3fv(vertices[5]);
113 | glVertex3fv(vertices[6]);
114 | glVertex3fv(vertices[2]);
115 | glEnd();
116 |
117 | }
118 |
119 | #endif
--------------------------------------------------------------------------------
/rsm/GL/rt.h:
--------------------------------------------------------------------------------
1 | #ifndef _RT_H_
2 | #define _RT_H_
3 |
4 | #include
5 | #include
6 | #include
7 | #include
8 |
9 | #include
10 | #include
11 | #include
12 | #include
13 |
14 | class RenderTarget {
15 | private:
16 | GLuint _frameBuffer;
17 | GLuint _renderBuffer;
18 | GLuint _texture;
19 |
20 | int _size;
21 | public:
22 | virtual ~RenderTarget() {
23 | glDeleteTextures(1, &_texture);
24 | glDeleteRenderbuffers(1, &_renderBuffer);
25 | glDeleteFramebuffers(1, &_frameBuffer);
26 | }
27 |
28 | const int Size() {
29 | return _size;
30 | }
31 |
32 | void Bind() {
33 | glViewport(0, 0, _size, _size);
34 | glBindFramebuffer(GL_FRAMEBUFFER, _frameBuffer);
35 | }
36 |
37 | void Unbind() {
38 | glBindFramebuffer(GL_FRAMEBUFFER, 0);
39 | }
40 |
41 | GLuint Texture() {
42 | return _texture;
43 | }
44 |
45 | RenderTarget(const int size, GLuint wrap = GL_CLAMP_TO_EDGE, GLuint filterParam = GL_LINEAR, GLuint internalFormat = GL_RGBA32F, GLuint type = GL_FLOAT) :
46 | _size(size) {
47 | glGenTextures(1, &_texture);
48 | glBindTexture(GL_TEXTURE_2D, _texture);
49 | glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, _size, _size, 0, GL_RGBA, type, NULL);
50 | static const GLfloat border[] = {1, 1, 1, 1};
51 | glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border);
52 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap);
53 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap);
54 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filterParam);
55 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filterParam);
56 |
57 | glGenFramebuffers(1, &_frameBuffer);
58 | glBindFramebuffer(GL_FRAMEBUFFER, _frameBuffer);
59 | glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, _texture, 0);
60 |
61 | glGenRenderbuffers(1, &_renderBuffer);
62 | glBindRenderbuffer(GL_RENDERBUFFER, _renderBuffer);
63 | glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, _size, _size);
64 | glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, _renderBuffer);
65 |
66 | glBindTexture(GL_TEXTURE_2D, 0);
67 | glBindRenderbuffer(GL_RENDERBUFFER, 0);
68 | glBindFramebuffer(GL_FRAMEBUFFER, 0);
69 | }
70 | };
71 |
72 |
73 | #endif
--------------------------------------------------------------------------------
/rsm/GL/shader.cpp:
--------------------------------------------------------------------------------
1 | #include "shader.h"
2 |
3 |
4 | enum ShaderGLType {
5 | GLSL_VS,
6 | GLSL_FS
7 | };
8 |
9 | void getErrorLog(GLuint shader, std::set* errorLines = NULL)
10 | {
11 | GLsizei bufSize = 0;
12 | glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &bufSize);
13 |
14 | if (bufSize > 1) {
15 | GLchar *infoLog;
16 | GLsizei length;
17 |
18 | infoLog = new GLchar[bufSize];
19 |
20 | glGetShaderInfoLog(shader, bufSize, &length, infoLog);
21 | // Logger::Instance()->OutputString("Compile Status: " + std::string(infoLog));
22 | std::cerr << "Compile Status: " + std::string(infoLog) << std::endl;
23 |
24 | // 適当な解析
25 | if (errorLines != NULL) {
26 | std::string tmpStr;
27 | for (int i = 0; i < bufSize; i ++) {
28 | if (infoLog[i] == '\n') {
29 | int num = 0;
30 | int numcnt = 0;
31 | bool inNum = false;
32 | for (unsigned int j = 0; j < tmpStr.length(); j ++) {
33 | if (inNum) {
34 | if (isdigit(tmpStr[j])) {
35 | num = num * 10 + (tmpStr[j] - '0');
36 | } else {
37 | inNum = false;
38 | numcnt ++;
39 |
40 | // 二番目の数字
41 | if (numcnt == 2) {
42 | errorLines->insert(num);
43 | }
44 | }
45 | } else {
46 | if (isdigit(tmpStr[j])) {
47 | inNum = true;
48 | num = num * 10 + (tmpStr[j] - '0');
49 | }
50 | }
51 | }
52 | tmpStr = "";
53 | } else {
54 | tmpStr += infoLog[i];
55 | }
56 | }
57 | }
58 |
59 | delete[] infoLog;
60 | }
61 | }
62 |
63 | GLuint CompileShader(ShaderGLType type, const GLchar* source, std::set* errorLines = NULL)
64 | {
65 | GLint status;
66 | unsigned int prog = 0;
67 | switch (type) {
68 | case GLSL_VS:
69 | {
70 | prog = glCreateShader(GL_VERTEX_SHADER);
71 | glShaderSource(prog, 1, &source, 0);
72 | glCompileShader(prog);
73 | glGetShaderiv(prog, GL_COMPILE_STATUS, &status);
74 | if (status == GL_FALSE) {
75 | getErrorLog(prog, errorLines);
76 | std::cerr << "Compile error in vertex shader." << std::endl;
77 | glDeleteShader(prog);
78 | prog = 0;
79 | }
80 |
81 | return prog;
82 | }break;
83 | case GLSL_FS:
84 | {
85 | prog = glCreateShader(GL_FRAGMENT_SHADER);
86 | glShaderSource(prog, 1, &source, 0);
87 | glCompileShader(prog);
88 | glGetShaderiv(prog, GL_COMPILE_STATUS, &status);
89 | if (status == GL_FALSE) {
90 | getErrorLog(prog, errorLines);
91 | std::cerr << "Compile error in fragment shader." << std::endl;
92 | glDeleteShader(prog);
93 | prog = 0;
94 | }
95 |
96 | return prog;
97 | }break;
98 | }
99 | return 0;
100 | }
101 |
102 |
103 | GLuint LinkShader(GLuint vsh, GLuint fsh)
104 | {
105 | GLuint program = 0;
106 | if (vsh != 0 && fsh != 0) {
107 | program = glCreateProgram();
108 | glAttachShader(program, vsh);
109 | glAttachShader(program, fsh);
110 | // リンク
111 | glLinkProgram(program);
112 | GLint status;
113 | glGetProgramiv(program, GL_LINK_STATUS, &status);
114 | if (status == GL_FALSE) {
115 | std::cerr << "Link Error." << std::endl;
116 | glDeleteProgram(program);
117 | program = 0;
118 | }
119 | }
120 |
121 | return program;
122 | }
123 |
124 | Shader::Shader() {
125 | OK = false;
126 | shaderProgram = 0;
127 | }
128 |
129 | GLuint Shader::CompileFromFile(const std::string& fsfilename, const std::string& vsfilename) {
130 | std::string fsshader, vsshader;
131 | FILE* fp = fopen(fsfilename.c_str(), "rt");
132 | if (fp != NULL) {
133 | char buf[1024];
134 | while (fgets(buf, 1024, fp) != NULL) {
135 | fsshader += buf;
136 | }
137 | fclose(fp);
138 | }
139 | fp = fopen(vsfilename.c_str(), "rt");
140 | if (fp != NULL) {
141 | char buf[1024];
142 | while (fgets(buf, 1024, fp) != NULL) {
143 | vsshader += buf;
144 | }
145 | fclose(fp);
146 | }
147 |
148 | return Compile(fsshader, vsshader);
149 | }
150 |
151 | GLuint Shader::Compile(const std::string& fsshader, const std::string& vsshader) {
152 | errorLinesVS.clear();
153 | GLuint vsh = CompileShader(GLSL_VS, vsshader.c_str(), &errorLinesVS);
154 | if (vsh == 0) {
155 | std::cerr << "Vertex Shader Error." << std::endl;
156 | return 0;
157 | }
158 |
159 | errorLinesFS.clear();
160 | GLuint fsh = CompileShader(GLSL_FS, fsshader.c_str(), &errorLinesFS);
161 | if (fsh == 0) {
162 | std::cerr << "Fragment Shader Error." << std::endl;
163 | glDeleteShader(vsh);
164 | return 0;
165 | }
166 |
167 | GLuint program = LinkShader(vsh, fsh);
168 | if (program != 0) {
169 | OK = true;
170 | if (shaderProgram != 0)
171 | glDeleteProgram(shaderProgram);
172 | shaderProgram = program;
173 |
174 | glDeleteShader(vsh);
175 | glDeleteShader(fsh);
176 | } else
177 | return 0;
178 |
179 | // 新しくシェーダープログラムセットされたらここにくる
180 | return shaderProgram;
181 | }
182 |
183 | Shader::~Shader() {
184 | if (shaderProgram != 0) {
185 | glDeleteProgram(shaderProgram);
186 | }
187 | }
188 |
189 | bool Shader::Valid() {
190 | return OK;
191 | }
192 |
193 | void Shader::Bind() {
194 | glUseProgram(shaderProgram);
195 | }
196 |
197 | void Shader::Unbind() {
198 | glUseProgram(0);
199 | }
200 |
201 | void Shader::SetUniform(const GLchar* name, int i) {
202 | if (shaderProgram) {
203 | GLuint id = glGetUniformLocation(shaderProgram, name);
204 | if (id != -1)
205 | glUniform1i(id, i);
206 | }
207 | }
208 |
209 | void Shader:: SetUniform(const GLchar* name, float v) {
210 | if (shaderProgram) {
211 | GLuint id = glGetUniformLocation(shaderProgram, name);
212 | if (id != -1)
213 | glUniform1f(id, v);
214 | }
215 | }
216 |
217 | void Shader:: SetUniform(const GLchar* name, float* fv, int size) {
218 | if (shaderProgram) {
219 | GLuint id = glGetUniformLocation(shaderProgram, name);
220 | if (id != -1)
221 | glUniform1fv(id, size, fv);
222 | }
223 | }
224 |
225 | void Shader:: SetUniform(const GLchar* name, float x, float y) {
226 | if (shaderProgram) {
227 | GLuint id = glGetUniformLocation(shaderProgram, name);
228 | if (id != -1)
229 | glUniform2f(id, x, y);
230 | }
231 | }
232 |
233 | void Shader::SetUniform(const GLchar* name, float x, float y, float z, float w) {
234 | if (shaderProgram) {
235 | GLuint id = glGetUniformLocation(shaderProgram, name);
236 | if (id != -1)
237 | glUniform4f(id, x, y, z, w);
238 | }
239 | }
240 |
241 |
242 | void Shader::SetUniformMatrix4x4(const GLchar* name, float *fv) {
243 | if (shaderProgram) {
244 | GLuint id = glGetUniformLocation(shaderProgram, name);
245 | if (id != -1)
246 | glUniformMatrix4fv(id, 1, false, fv);
247 | }
248 | }
--------------------------------------------------------------------------------
/rsm/GL/shader.h:
--------------------------------------------------------------------------------
1 | #ifndef _SHADER_H_
2 | #define _SHADER_H_
3 |
4 | #include
5 | #include
6 | #include
7 | #include
8 |
9 | #include
10 | #include
11 | #include
12 | #include
13 |
14 |
15 | class Shader {
16 | private:
17 | bool OK;
18 | GLuint shaderProgram;
19 |
20 | std::set errorLinesFS;
21 | std::set errorLinesVS;
22 | public:
23 | Shader();
24 | virtual ~Shader();
25 |
26 | const std::set& GetErrorLinesFS() { return errorLinesFS; }
27 | const std::set& GetErrorLinesVS() { return errorLinesVS; }
28 |
29 | GLuint Compile(const std::string& fsshader, const std::string& vsshader);
30 |
31 | GLuint CompileFromFile(const std::string& fsfilename, const std::string& vsfilename);
32 |
33 | bool Valid();
34 | void Bind();
35 | void Unbind();
36 | void SetUniform(const GLchar* name, int i);
37 | void SetUniform(const GLchar* name, float v);
38 | void SetUniform(const GLchar* name, float* fv, int size);
39 | void SetUniform(const GLchar* name, float x, float y);
40 | void SetUniform(const GLchar* name, float x, float y, float z, float w);
41 | void SetUniformMatrix4x4(const GLchar* name, float *fv);
42 | };
43 |
44 |
45 | #endif
46 |
--------------------------------------------------------------------------------
/rsm/GL/shader/blur.vs:
--------------------------------------------------------------------------------
1 | // 頂点シェーダ
2 |
3 | void main() {
4 | gl_Position = ftransform();
5 | }
--------------------------------------------------------------------------------
/rsm/GL/shader/blurx.fs:
--------------------------------------------------------------------------------
1 | // フラグメントシェーダ
2 |
3 | uniform sampler2D texture;
4 | uniform vec2 resolution;
5 |
6 | const float blurSize = 3/512.0;
7 |
8 | void main(void)
9 | {
10 | vec4 sum = vec4(0.0);
11 | vec2 vTexCoord = gl_FragCoord.xy / resolution.xy;
12 |
13 | // blur in y (vertical)
14 | // take nine samples, with the distance blurSize between them
15 | sum += texture2D(texture, vec2(vTexCoord.x, vTexCoord.y - 4.0*blurSize)) * 0.05;
16 | sum += texture2D(texture, vec2(vTexCoord.x, vTexCoord.y - 3.0*blurSize)) * 0.09;
17 | sum += texture2D(texture, vec2(vTexCoord.x, vTexCoord.y - 2.0*blurSize)) * 0.12;
18 | sum += texture2D(texture, vec2(vTexCoord.x, vTexCoord.y - blurSize)) * 0.15;
19 | sum += texture2D(texture, vec2(vTexCoord.x, vTexCoord.y)) * 0.16;
20 | sum += texture2D(texture, vec2(vTexCoord.x, vTexCoord.y + blurSize)) * 0.15;
21 | sum += texture2D(texture, vec2(vTexCoord.x, vTexCoord.y + 2.0*blurSize)) * 0.12;
22 | sum += texture2D(texture, vec2(vTexCoord.x, vTexCoord.y + 3.0*blurSize)) * 0.09;
23 | sum += texture2D(texture, vec2(vTexCoord.x, vTexCoord.y + 4.0*blurSize)) * 0.05;
24 |
25 | gl_FragColor = sum;
26 | }
--------------------------------------------------------------------------------
/rsm/GL/shader/blury.fs:
--------------------------------------------------------------------------------
1 | // フラグメントシェーダ
2 |
3 | uniform sampler2D texture;
4 | uniform vec2 resolution;
5 |
6 | const float blurSize = 3/512.0;
7 |
8 | void main(void)
9 | {
10 | vec4 sum = vec4(0.0);
11 | vec2 vTexCoord = gl_FragCoord.xy / resolution.xy;
12 |
13 | // blur in y (vertical)
14 | // take nine samples, with the distance blurSize between them
15 | sum += texture2D(texture, vec2(vTexCoord.x - 4.0*blurSize, vTexCoord.y)) * 0.05;
16 | sum += texture2D(texture, vec2(vTexCoord.x - 3.0*blurSize, vTexCoord.y)) * 0.09;
17 | sum += texture2D(texture, vec2(vTexCoord.x - 2.0*blurSize, vTexCoord.y)) * 0.12;
18 | sum += texture2D(texture, vec2(vTexCoord.x - blurSize, vTexCoord.y)) * 0.15;
19 | sum += texture2D(texture, vec2(vTexCoord.x, vTexCoord.y)) * 0.16;
20 | sum += texture2D(texture, vec2(vTexCoord.x + blurSize, vTexCoord.y)) * 0.15;
21 | sum += texture2D(texture, vec2(vTexCoord.x + 2.0*blurSize, vTexCoord.y)) * 0.12;
22 | sum += texture2D(texture, vec2(vTexCoord.x + 3.0*blurSize, vTexCoord.y)) * 0.09;
23 | sum += texture2D(texture, vec2(vTexCoord.x + 4.0*blurSize, vTexCoord.y)) * 0.05;
24 |
25 | gl_FragColor = sum;
26 | }
--------------------------------------------------------------------------------
/rsm/GL/shader/gi.fs:
--------------------------------------------------------------------------------
1 | // フラグメントシェーダ
2 | uniform vec4 uAmbient;
3 | uniform vec4 uLightIntensity;
4 |
5 | uniform mat4 uCamProj;
6 | uniform mat4 uCamView;
7 | uniform mat4 uLightProj;
8 | uniform mat4 uLightView;
9 |
10 | varying vec4 vWorldPosition;
11 | varying vec3 vWorldNormal;
12 | varying vec4 vColor;
13 |
14 | uniform sampler2D shadowMap;
15 |
16 | uniform sampler2D vplTexture;
17 | uniform sampler2D vplPosTexture;
18 | uniform sampler2D vplNormalTexture;
19 |
20 |
21 | float RND_1d(vec2 x)
22 | {
23 | uint n = floatBitsToUint(x.y * 214013.0 + x.x * 2531011.0);
24 | n = n * (n * n * 15731u + 789221u);
25 | n = (n >> 9u) | 0x3F800000u;
26 |
27 | return 2.0 - uintBitsToFloat(n);
28 | }
29 |
30 | void main() {
31 | vec3 worldNormal = normalize(vWorldNormal);
32 | vec3 lightPosition = (uLightView * vWorldPosition).xyz; // ライト空間での位置
33 | vec3 lightPositionNoramalized = normalize(lightPosition);
34 |
35 | mat4 lightNormalMatrix = transpose(inverse(uLightView)); // CPU上で求めておきましょう
36 | vec3 lightSurfaceNormal = (lightNormalMatrix * vec4(worldNormal, 1.0)).xyz;
37 |
38 | vec3 lambert = max(0.0, dot(lightSurfaceNormal, vec3(0, 0, 1)));
39 |
40 | // 影
41 | float depth1 = clamp(-lightPosition.z / 100.0, 0.0, 1.0); // ライトからの距離を求める
42 | vec4 lightDevice = uLightProj * uLightView * vWorldPosition; // ライトへの射影した結果
43 | vec2 lightDeviceNormalized = lightDevice.xy / lightDevice.w;
44 | vec2 lightUV = (lightDeviceNormalized.xy / 2.0) + vec2(0.5, 0.5);
45 |
46 | // やばい
47 |
48 | vec4 indc = vec4(0.0, 0.0, 0.0, 0.0);
49 | float rm = 0.1;
50 | vec2 seed = vec2(vWorldPosition.x + vWorldPosition.y, vWorldPosition.y + vWorldPosition.z);
51 |
52 | float gzi1, gzi2;
53 | for (int i = 0; i < 64; i ++) {
54 | gzi1 = RND_1d(seed + vec2(gzi1 + i, gzi2 + i));
55 | gzi2 = RND_1d(seed + vec2(gzi1 + i, gzi2 + i));
56 |
57 | vec2 sample = lightUV + vec2(rm * gzi1 * sin(2.0 * 3.14159 * gzi2), rm * gzi1 * cos(2.0 * 3.14159 * gzi2));
58 | vec4 vpl = texture2D(vplTexture, sample);
59 | vec4 vplPos = texture2D(vplPosTexture, sample);
60 | vec4 vplNormal = texture2D(vplNormalTexture, sample);
61 |
62 | vec4 L = normalize(vplPos - vWorldPosition);
63 | vec4 c = (vColor / 3.14159) * max(0.0, dot(worldNormal, L)) * step(0.0, -dot(worldNormal, vplNormal)) * vpl;
64 |
65 | indc = indc + (gzi1 * gzi1) * c * (4.0 * 3.14159) / 64.0;
66 | }
67 |
68 | gl_FragColor = indc;
69 | }
70 |
--------------------------------------------------------------------------------
/rsm/GL/shader/gi.vs:
--------------------------------------------------------------------------------
1 | // 頂点シェーダ
2 | varying vec4 vWorldPosition;
3 | varying vec3 vWorldNormal;
4 | varying vec4 vColor;
5 |
6 | uniform mat4 uModel;
7 | uniform mat4 uCamProj;
8 | uniform mat4 uCamView;
9 |
10 | void main() {
11 | vColor = gl_Color;
12 | vWorldNormal = gl_Normal;
13 | vWorldPosition = uModel * gl_Vertex;
14 |
15 | gl_Position = uCamProj * uCamView * vWorldPosition;
16 | }
--------------------------------------------------------------------------------
/rsm/GL/shader/light.fs:
--------------------------------------------------------------------------------
1 | // フラグメントシェーダ
2 |
3 | uniform mat4 uLightProj;
4 | uniform mat4 uLightView;
5 |
6 | varying vec4 vWorldPosition;
7 | varying vec3 vWorldNormal;
8 | varying vec4 vColor;
9 |
10 | void main() {
11 | vec3 lightPosition = (uLightView * vWorldPosition).xyz; // ライト空間での位置
12 | gl_FragColor = vec4(vec3(-lightPosition.z / 100.0), 0.0);
13 | }
14 |
15 |
--------------------------------------------------------------------------------
/rsm/GL/shader/light.vs:
--------------------------------------------------------------------------------
1 | // 頂点シェーダ
2 | varying vec4 vWorldPosition;
3 | varying vec3 vWorldNormal;
4 | varying vec4 vColor;
5 |
6 | uniform mat4 uModel;
7 | uniform mat4 uCamProj;
8 | uniform mat4 uCamView;
9 |
10 | uniform mat4 uLightProj;
11 | uniform mat4 uLightView;
12 |
13 | void main() {
14 | vColor = gl_Color;
15 | vWorldNormal = gl_Normal;
16 | vWorldPosition = uModel * gl_Vertex;
17 |
18 | gl_Position = uLightProj * uLightView * vWorldPosition;
19 | }
--------------------------------------------------------------------------------
/rsm/GL/shader/post.fs:
--------------------------------------------------------------------------------
1 | // フラグメントシェーダ
2 |
3 | uniform float time;
4 | uniform vec2 resolution;
5 | uniform sampler2D texture;
6 |
7 | float rand(vec2 n) {
8 | return 0.5 + 0.5 *
9 | fract(sin(dot(n.xy, vec2(12.9898, 78.233)))* 43758.5453);
10 | }
11 |
12 | void main() {
13 | gl_FragColor = texture2D(texture, gl_FragCoord.xy / resolution.xy);
14 | }
--------------------------------------------------------------------------------
/rsm/GL/shader/post.vs:
--------------------------------------------------------------------------------
1 | // 頂点シェーダ
2 |
3 | void main() {
4 | gl_Position = ftransform();
5 | }
--------------------------------------------------------------------------------
/rsm/GL/shader/shader.fs:
--------------------------------------------------------------------------------
1 | // フラグメントシェーダ
2 | uniform vec2 resolution;
3 |
4 | uniform vec4 uAmbient;
5 | uniform vec4 uLightIntensity;
6 |
7 | uniform mat4 uCamProj;
8 | uniform mat4 uCamView;
9 | uniform mat4 uLightProj;
10 | uniform mat4 uLightView;
11 | uniform mat4 uLightNormalMatrix;
12 |
13 | varying vec4 vWorldPosition;
14 | varying vec3 vWorldNormal;
15 | varying vec4 vColor;
16 |
17 | uniform sampler2D shadowMap;
18 | uniform sampler2D giTexture;
19 |
20 | void main() {
21 | vec3 worldNormal = normalize(vWorldNormal);
22 | vec3 lightPosition = (uLightView * vWorldPosition).xyz; // ライト空間での位置
23 | vec3 lightPositionNoramalized = normalize(lightPosition);
24 |
25 | vec3 lightSurfaceNormal = (uLightNormalMatrix * vec4(worldNormal, 1.0)).xyz;
26 |
27 | vec3 lambert = max(0.0, dot(lightSurfaceNormal, vec3(0, 0, 1)));
28 |
29 | // 影
30 | float bias = 0.0004;
31 | float depth1 = clamp(-lightPosition.z / 100.0, 0.0, 1.0); // ライトからの距離を求める
32 | vec4 lightDevice = uLightProj * uLightView * vWorldPosition; // ライトへの射影した結果
33 | vec2 lightDeviceNormalized = lightDevice.xy / lightDevice.w;
34 | vec2 lightUV = (lightDeviceNormalized.xy / 2.0) + vec2(0.5, 0.5);
35 |
36 | // 普通のShadowMap
37 | float depth2 = texture2D(shadowMap, lightUV).x + bias;
38 | float shadow = 0.0;
39 | if (depth1 < depth2)
40 | shadow = 1.0;
41 |
42 | vec3 col = shadow * uLightIntensity * lambert * (vColor / 3.14159) + 0.8 * uAmbient * (vColor / 3.14159);
43 |
44 | // GlobalIllumination
45 | vec4 icol = texture2D(giTexture, gl_FragCoord.xy / resolution.xy);
46 | // col = icol;
47 | col = col + icol;
48 |
49 | col = pow(col * 2.2, 1.0 / 1.0);
50 | gl_FragColor = vec4(col, 1.0);
51 | }
52 |
--------------------------------------------------------------------------------
/rsm/GL/shader/shader.vs:
--------------------------------------------------------------------------------
1 | // 頂点シェーダ
2 | varying vec4 vWorldPosition;
3 | varying vec3 vWorldNormal;
4 | varying vec4 vColor;
5 |
6 | uniform mat4 uModel;
7 | uniform mat4 uCamProj;
8 | uniform mat4 uCamView;
9 |
10 | void main() {
11 | vColor = gl_Color;
12 | vWorldNormal = gl_Normal;
13 | vWorldPosition = uModel * gl_Vertex;
14 |
15 | gl_Position = uCamProj * uCamView * vWorldPosition;
16 | }
--------------------------------------------------------------------------------
/rsm/GL/shader/vpl.fs:
--------------------------------------------------------------------------------
1 | // フラグメントシェーダ
2 | uniform vec4 uAmbient;
3 | uniform vec4 uLightIntensity;
4 |
5 | uniform mat4 uCamProj;
6 | uniform mat4 uCamView;
7 | uniform mat4 uLightProj;
8 | uniform mat4 uLightView;
9 |
10 | uniform mat4 uLightNormalMatrix;
11 |
12 | varying vec4 vWorldPosition;
13 | varying vec3 vWorldNormal;
14 | varying vec4 vColor;
15 |
16 | void main() {
17 | vec3 worldNormal = normalize(vWorldNormal);
18 | vec3 lightPosition = (uLightView * vWorldPosition).xyz; // ライト空間での位置
19 | vec3 lightPositionNoramalized = normalize(lightPosition);
20 |
21 | vec3 lightSurfaceNormal = (uLightNormalMatrix * vec4(worldNormal, 1.0)).xyz;
22 |
23 | vec3 lambert = max(0.0, dot(lightSurfaceNormal, vec3(0, 0, 1)));
24 |
25 | vec3 col = uLightIntensity * lambert * (vColor / 3.14159);
26 |
27 | gl_FragColor = vec4(col, 1.0);
28 | }
--------------------------------------------------------------------------------
/rsm/GL/shader/vpl.vs:
--------------------------------------------------------------------------------
1 | // 頂点シェーダ
2 | varying vec4 vWorldPosition;
3 | varying vec3 vWorldNormal;
4 | varying vec4 vColor;
5 |
6 | uniform mat4 uModel;
7 | uniform mat4 uCamProj;
8 | uniform mat4 uCamView;
9 |
10 | uniform mat4 uLightProj;
11 | uniform mat4 uLightView;
12 |
13 |
14 | void main() {
15 | vColor = gl_Color;
16 | vWorldNormal = gl_Normal;
17 | vWorldPosition = uModel * gl_Vertex;
18 |
19 | gl_Position = uLightProj * uLightView * vWorldPosition;
20 | }
--------------------------------------------------------------------------------
/rsm/GL/shader/vpl_normal.fs:
--------------------------------------------------------------------------------
1 | // フラグメントシェーダ
2 | uniform vec4 uAmbient;
3 | uniform vec4 uLightIntensity;
4 |
5 | uniform mat4 uCamProj;
6 | uniform mat4 uCamView;
7 | uniform mat4 uLightProj;
8 | uniform mat4 uLightView;
9 |
10 | varying vec4 vWorldPosition;
11 | varying vec3 vWorldNormal;
12 | varying vec4 vColor;
13 |
14 | void main() {
15 | vec3 worldNormal = normalize(vWorldNormal);
16 | gl_FragColor = vec4(worldNormal, 1.0);
17 | }
--------------------------------------------------------------------------------
/rsm/GL/shader/vpl_normal.vs:
--------------------------------------------------------------------------------
1 | // 頂点シェーダ
2 | varying vec4 vWorldPosition;
3 | varying vec3 vWorldNormal;
4 | varying vec4 vColor;
5 |
6 | uniform mat4 uModel;
7 | uniform mat4 uCamProj;
8 | uniform mat4 uCamView;
9 |
10 | uniform mat4 uLightProj;
11 | uniform mat4 uLightView;
12 |
13 |
14 | void main() {
15 | vColor = gl_Color;
16 | vWorldNormal = gl_Normal;
17 | vWorldPosition = uModel * gl_Vertex;
18 |
19 | gl_Position = uLightProj * uLightView * vWorldPosition;
20 | }
--------------------------------------------------------------------------------
/rsm/GL/shader/vpl_pos.fs:
--------------------------------------------------------------------------------
1 | // フラグメントシェーダ
2 | uniform vec4 uAmbient;
3 | uniform vec4 uLightIntensity;
4 |
5 | uniform mat4 uCamProj;
6 | uniform mat4 uCamView;
7 | uniform mat4 uLightProj;
8 | uniform mat4 uLightView;
9 |
10 | varying vec4 vWorldPosition;
11 | varying vec3 vWorldNormal;
12 | varying vec4 vColor;
13 |
14 | void main() {
15 | gl_FragColor = vec4(vWorldPosition.xyz, 1.0);
16 | }
--------------------------------------------------------------------------------
/rsm/GL/shader/vpl_pos.vs:
--------------------------------------------------------------------------------
1 | // 頂点シェーダ
2 | varying vec4 vWorldPosition;
3 | varying vec3 vWorldNormal;
4 | varying vec4 vColor;
5 |
6 | uniform mat4 uModel;
7 | uniform mat4 uCamProj;
8 | uniform mat4 uCamView;
9 |
10 | uniform mat4 uLightProj;
11 | uniform mat4 uLightView;
12 |
13 |
14 | void main() {
15 | vColor = gl_Color;
16 | vWorldNormal = gl_Normal;
17 | vWorldPosition = uModel * gl_Vertex;
18 |
19 | gl_Position = uLightProj * uLightView * vWorldPosition;
20 | }
--------------------------------------------------------------------------------