Skip to content

Commit 0295be9

Browse files
author
powertomato
committed
Added normal_map test and shader added
1 parent 002ca98 commit 0295be9

13 files changed

+443
-2
lines changed

‎linux.mk

+2-1
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,8 @@ DEFINES+=-DSDL_SHADER_OPENGL \
55
TEST_CASES=color_mode \
66
context_switch \
77
all_the_shaders \
8-
vertex_buffer
8+
vertex_buffer \
9+
normal_map
910

1011
GCC=gcc
1112
GPP=g++

‎test/normal_map/main.c

+183
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,183 @@
1+
2+
#include <stdlib.h>
3+
#include <stdio.h>
4+
#include <SDL2/SDL.h>
5+
#include <SDL2/SDL_test_font.h>
6+
#include <SDL2/SDL_image.h>
7+
#include "../src/SDL_shader.h"
8+
#include "../src/SDL_SYS_RenderStructs.h"
9+
#include <math.h>
10+
#ifndef M_PI
11+
#define M_PI 3.14159265358979323846
12+
#endif /*M_PI*/
13+
14+
int mod(int a, int b)
15+
{
16+
int r = a % b;
17+
return r < 0 ? r + b : r;
18+
}
19+
20+
#ifdef _WIN32
21+
//prevents displaying the black console window
22+
//on windows systems
23+
//depending on the toolchain (settings) this is also required
24+
#include <windows.h>
25+
int WINAPI WinMain (HINSTANCE hThisInstance,
26+
HINSTANCE hPrevInstance,
27+
LPSTR lpszArgument,
28+
int nCmdShow)
29+
#else
30+
int main(int argc, char** argv)
31+
#endif
32+
{
33+
#ifdef _WIN32
34+
LPSTR *argv = __argv;
35+
int argc = __argc;
36+
(void) argv;
37+
(void) argc;
38+
#endif
39+
SDL_Window *screen;
40+
SDL_Renderer *renderer;
41+
42+
if ( SDL_Init(SDL_INIT_VIDEO) < 0 ){
43+
fprintf(stderr, "Error: %s \n", SDL_GetError());
44+
return 1;
45+
}
46+
47+
SDL_SetHint( SDL_HINT_RENDER_DRIVER, getenv("RENDER_DRIVER") );
48+
49+
int width = 800;
50+
int height = 600;
51+
screen = SDL_CreateWindow("Caption",
52+
SDL_WINDOWPOS_CENTERED,
53+
SDL_WINDOWPOS_CENTERED,
54+
width, height,
55+
SDL_WINDOW_RESIZABLE);
56+
// SDL_WINDOW_FULLSCREEN_DESKTOP );
57+
if ( screen == NULL ) {
58+
fprintf(stderr, "Error: %s \n", SDL_GetError());
59+
return 2;
60+
}
61+
renderer = SDL_CreateRenderer( screen, -1, SDL_RENDERER_ACCELERATED|SDL_RENDERER_TARGETTEXTURE );
62+
//renderer = SDL_CreateRenderer( screen, -1, SDL_RENDERER_SOFTWARE|SDL_RENDERER_TARGETTEXTURE );
63+
if ( renderer == NULL ) {
64+
fprintf(stderr, "Error: %s \n", SDL_GetError());
65+
return 3;
66+
}
67+
68+
SDL_RenderSetLogicalSize(renderer, width, height);
69+
70+
SDL_SetWindowTitle( screen, renderer->info.name );
71+
72+
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
73+
SDL_RenderClear(renderer);
74+
75+
SDL_shader_hint(SDL_GL_TEX0_NAME,"u_texture" );
76+
SDL_shader_hint(SDL_GL_TEX1_NAME,"u_normals" );
77+
SDL_Shader* shader = SDL_createShader( renderer, "../shaders/normal_map/normal_map" );
78+
79+
if ( shader == NULL ) {
80+
fprintf( stderr, "Error: %s \n", SDL_GetError() );
81+
}
82+
SDL_assert(shader != NULL);
83+
84+
SDL_Uniform* resolution = SDL_createUniform( shader, "Resolution" );
85+
SDL_Uniform* lightPos = SDL_createUniform( shader, "LightPos" );
86+
SDL_Uniform* lightColor = SDL_createUniform( shader, "LightColor" );
87+
SDL_Uniform* ambientColor = SDL_createUniform( shader, "AmbientColor" );
88+
SDL_Uniform* falloff = SDL_createUniform( shader, "Falloff" );
89+
90+
SDL_assert(resolution != NULL);
91+
SDL_assert(lightPos != NULL);
92+
SDL_assert(lightColor != NULL);
93+
SDL_assert(ambientColor != NULL);
94+
SDL_assert(falloff != NULL);
95+
96+
SDL_setUniform_f2( resolution, 800, 600 );
97+
SDL_setUniform_f3( lightPos, 0.5,0.5,0.075f );
98+
SDL_setUniform_f4( lightColor, 1, 0.7f, 0.7f, 7 );
99+
SDL_setUniform_f4( ambientColor, 1, 1, 1, 0.3f );
100+
SDL_setUniform_f3( falloff, 0.4f, 3, 20 );
101+
102+
SDL_Texture* tex[2];
103+
SDL_Surface* srf;
104+
char* names[] = {"../stone.png", "../stone_n.png"};
105+
for( int i=0; i<2; i++ ){
106+
srf = IMG_Load( names[i] );
107+
108+
SDL_PixelFormat* fmt = SDL_AllocFormat( SDL_PIXELFORMAT_ARGB8888 );
109+
SDL_assert(fmt != NULL);
110+
SDL_Surface* srf2 = SDL_ConvertSurface(srf, fmt, 0);
111+
SDL_assert(srf2 != NULL);
112+
113+
if ( !srf ) {
114+
fprintf(stderr, "Error: %s \n", SDL_GetError());
115+
return 5;
116+
}
117+
tex[i] = SDL_CreateTextureFromSurface(renderer, srf2 );
118+
119+
SDL_FreeSurface(srf);
120+
SDL_FreeSurface(srf2);
121+
}
122+
123+
SDL_SetRenderTarget( renderer, NULL );
124+
SDL_Event e;
125+
SDL_SetRenderDrawColor(renderer, 0,0,0,1);
126+
int ret = 0;
127+
int quit = 0;
128+
while ( !quit ) {
129+
//SDLTest_DrawString( renderer, 8, 8, shader_names[current_shader] );
130+
SDL_Rect dst = {0,0,800,600};
131+
ret = SDL_renderCopyShdArray( shader, tex,NULL,&dst,2 );
132+
if ( ret!=0 ){
133+
fprintf(stderr,"Err: %s\n", SDL_GetError());
134+
}
135+
136+
while (SDL_PollEvent(&e)){
137+
switch ( e.type ) {
138+
case SDL_QUIT:
139+
quit = 1;
140+
break;
141+
case SDL_KEYDOWN:
142+
switch ( e.key.keysym.sym ) {
143+
case SDLK_SPACE:
144+
break;
145+
case SDLK_TAB:
146+
break;
147+
}
148+
break;
149+
case SDL_MOUSEMOTION:
150+
shader->bindShader( shader );
151+
SDL_setUniform_f3( lightPos,
152+
(float) e.motion.x/800.0f,
153+
(float) 1.0f-e.motion.y/600.0f,
154+
0.450f );
155+
break;
156+
//case SDL_WINDOWEVENT:
157+
// SDL_updateViewport( shader );
158+
}
159+
}
160+
161+
SDL_RenderPresent(renderer);
162+
163+
SDL_SetRenderDrawColor(renderer, 160, 160, 160, 255);
164+
SDL_RenderClear(renderer);
165+
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
166+
167+
}
168+
169+
170+
SDL_destroyUniform(shader, resolution);
171+
SDL_destroyUniform(shader, lightPos);
172+
SDL_destroyUniform(shader, lightColor);
173+
SDL_destroyUniform(shader, ambientColor);
174+
SDL_destroyUniform(shader, falloff);
175+
176+
SDL_destroyShader( shader );
177+
SDL_DestroyTexture( tex[0] );
178+
SDL_DestroyTexture( tex[1] );
179+
SDL_DestroyRenderer( renderer );
180+
SDL_DestroyWindow( screen );
181+
SDL_Quit();
182+
return 0;
183+
}

‎test/shaders/normal_map/normal_map.d3d.hlsl

+98
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,98 @@
1+
/* based on https://github.com/mattdesl/lwjgl-basics/wiki/ShaderLesson6 */
2+
3+
texture xColoredTexture;
4+
float4x4 world_view_projection : WORLDVIEWPROJECTION;
5+
6+
float2 Resolution; //resolution of screen
7+
float3 LightPos; //light position, normalized
8+
float4 LightColor; //light RGBA -- alpha is intensity
9+
float4 AmbientColor; //ambient RGBA -- alpha is intensity
10+
float3 Falloff; //attenuation coefficients
11+
12+
struct AppToVertex {
13+
float4 pos : POSITION;
14+
float2 texcoord : TEXCOORD0;
15+
float4 color : COLOR0;
16+
};
17+
18+
struct VertexToPixel {
19+
float4 pos : POSITION;
20+
float2 texcoord : TEXCOORD0;
21+
float4 color : COLOR0;
22+
};
23+
24+
struct PixelToFrame {
25+
float4 color : COLOR0;
26+
};
27+
28+
29+
30+
sampler u_texture = sampler_state {
31+
texture = <xColoredTexture>;
32+
magfilter = LINEAR;
33+
minfilter = LINEAR;
34+
mipfilter = LINEAR;
35+
AddressU = mirror;
36+
AddressV = mirror;
37+
};
38+
39+
sampler u_normals = sampler_state {
40+
texture = <xColoredTexture>;
41+
magfilter = LINEAR;
42+
minfilter = LINEAR;
43+
mipfilter = LINEAR;
44+
AddressU = mirror;
45+
AddressV = mirror;
46+
};
47+
48+
49+
VertexToPixel VertexShaderMain( AppToVertex vs_in ) {
50+
VertexToPixel vs_out = (VertexToPixel)0;
51+
vs_out.pos = mul(world_view_projection, vs_in.pos);
52+
vs_out.texcoord = vs_in.texcoord;
53+
vs_out.color = vs_in.color;
54+
55+
return vs_out;
56+
}
57+
58+
PixelToFrame PixelShaderMain(VertexToPixel ps_in) {
59+
PixelToFrame ps_out = (PixelToFrame)0;
60+
61+
//RGBA of our diffuse color
62+
float4 DiffuseColor = tex2D(u_texture, ps_in.texcoord );
63+
64+
//RGB of our normal map
65+
float3 NormalMap = tex2D(u_normals, ps_in.texcoord).rgb;
66+
67+
//The delta position of light
68+
ps_in.texcoord.y = 1-ps_in.texcoord.y;
69+
float3 LightDir = float3(LightPos.xy - (ps_in.texcoord ), LightPos.z);
70+
71+
//Correct for aspect ratio
72+
LightDir.x *= Resolution.x / Resolution.y;
73+
74+
//Determine distance (used for attenuation) BEFORE we normalize our LightDir
75+
float D = length(LightDir);
76+
77+
//normalize our vectors
78+
float3 N = normalize(NormalMap * 2.0 - 1.0);
79+
float3 L = normalize(LightDir);
80+
81+
//Pre-multiply light color with intensity
82+
//Then perform "N dot L" to determine our diffuse term
83+
float3 Diffuse = (LightColor.rgb * LightColor.a) * max(dot(N, L), 0.0);
84+
85+
//pre-multiply ambient color with intensity
86+
float3 Ambient = AmbientColor.rgb * AmbientColor.a;
87+
88+
//calculate attenuation
89+
float Attenuation = 1.0 / ( Falloff.x + (Falloff.y*D) + (Falloff.z*D*D) );
90+
91+
//the calculation which brings it all together
92+
float3 Intensity = Ambient + Diffuse * Attenuation;
93+
float3 FinalColor = DiffuseColor.rgb * Intensity;
94+
95+
ps_out.color = float4(FinalColor, DiffuseColor.a) * ps_in.color;
96+
return ps_out;
97+
}
98+

‎test/shaders/normal_map/normal_map.gl.frag

+62
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
#version 120
2+
/* based on https://github.com/mattdesl/lwjgl-basics/wiki/ShaderLesson6 */
3+
4+
5+
#ifdef GL_ARB_texture_rectangle
6+
#extension GL_ARB_texture_rectangle : enable
7+
#define sampler2D sampler2DRect
8+
#define texture2D texture2DRect
9+
#endif
10+
11+
vec4 convertColor(int type, vec4 color);
12+
uniform int color_mode;
13+
14+
//attributes from vertex shader
15+
// gl_Color, gl_TexCoord[0].st
16+
17+
//our texture samplers
18+
uniform sampler2D u_texture; //diffuse map
19+
uniform sampler2D u_normals; //normal map
20+
21+
//values used for shading algorithm...
22+
uniform vec2 Resolution; //resolution of screen
23+
uniform vec3 LightPos; //light position, normalized
24+
uniform vec4 LightColor; //light RGBA -- alpha is intensity
25+
uniform vec4 AmbientColor; //ambient RGBA -- alpha is intensity
26+
uniform vec3 Falloff; //attenuation coefficients
27+
28+
void main() {
29+
//RGBA of our diffuse color
30+
vec4 DiffuseColor = texture2D(u_texture, gl_TexCoord[0].st);
31+
32+
//RGB of our normal map
33+
vec3 NormalMap = texture2D(u_normals, gl_TexCoord[0].st).rgb;
34+
35+
//The delta position of light
36+
vec3 LightDir = vec3(LightPos.xy - (gl_FragCoord.xy / Resolution.xy), LightPos.z);
37+
38+
//Correct for aspect ratio
39+
LightDir.x *= Resolution.x / Resolution.y;
40+
41+
//Determine distance (used for attenuation) BEFORE we normalize our LightDir
42+
float D = length(LightDir);
43+
44+
//normalize our vectors
45+
vec3 N = normalize(NormalMap * 2.0 - 1.0);
46+
vec3 L = normalize(LightDir);
47+
48+
//Pre-multiply light color with intensity
49+
//Then perform "N dot L" to determine our diffuse term
50+
vec3 Diffuse = (LightColor.rgb * LightColor.a) * max(dot(N, L), 0.0);
51+
52+
//pre-multiply ambient color with intensity
53+
vec3 Ambient = AmbientColor.rgb * AmbientColor.a;
54+
55+
//calculate attenuation
56+
float Attenuation = 1.0 / ( Falloff.x + (Falloff.y*D) + (Falloff.z*D*D) );
57+
58+
//the calculation which brings it all together
59+
vec3 Intensity = Ambient + Diffuse * Attenuation;
60+
vec3 FinalColor = DiffuseColor.rgb * Intensity;
61+
gl_FragColor = gl_Color * vec4(FinalColor, DiffuseColor.a);
62+
}

‎test/shaders/normal_map/normal_map.gl.vert

+13
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
#version 120
2+
3+
uniform mat4 world_view_projection;
4+
5+
attribute vec4 position;
6+
attribute vec4 color;
7+
attribute vec2 texCoords;
8+
9+
void main(void){
10+
gl_FrontColor = color;
11+
gl_Position = world_view_projection * position;
12+
gl_TexCoord[0] = vec4(texCoords,1,1);
13+
}

0 commit comments

Comments
 (0)