aboutsummaryrefslogtreecommitdiff
path: root/examples
diff options
context:
space:
mode:
Diffstat (limited to 'examples')
-rw-r--r--examples/core_input_gamepad.c3
-rw-r--r--examples/physics_basic_rigidbody.c17
-rw-r--r--examples/physics_forces.c14
-rw-r--r--examples/resources/shaders/glsl100/bloom.fs2
-rw-r--r--examples/resources/shaders/glsl100/swirl.fs2
-rw-r--r--examples/resources/shaders/glsl330/bloom.fs2
-rw-r--r--examples/resources/shaders/glsl330/phong.fs82
-rw-r--r--examples/resources/shaders/glsl330/phong.vs29
-rw-r--r--examples/resources/shaders/glsl330/swirl.fs2
-rw-r--r--examples/resources/shaders/standard.fs136
-rw-r--r--examples/resources/shaders/standard.vs23
-rw-r--r--examples/shaders_basic_lighting.c171
-rw-r--r--examples/shaders_standard_lighting.c118
13 files changed, 299 insertions, 302 deletions
diff --git a/examples/core_input_gamepad.c b/examples/core_input_gamepad.c
index 1de2d424..6c356829 100644
--- a/examples/core_input_gamepad.c
+++ b/examples/core_input_gamepad.c
@@ -36,7 +36,8 @@ int main()
//----------------------------------------------------------------------------------
if (IsGamepadAvailable(GAMEPAD_PLAYER1))
{
- gamepadMovement = GetGamepadMovement(GAMEPAD_PLAYER1);
+ gamepadMovement.x = GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LEFT_X);
+ gamepadMovement.y = GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LEFT_Y);
ballPosition.x += gamepadMovement.x;
ballPosition.y -= gamepadMovement.y;
diff --git a/examples/physics_basic_rigidbody.c b/examples/physics_basic_rigidbody.c
index 917813ad..cd09f070 100644
--- a/examples/physics_basic_rigidbody.c
+++ b/examples/physics_basic_rigidbody.c
@@ -30,26 +30,26 @@ int main()
bool isDebug = false;
// Create rectangle physic object
- PhysicObject *rectangle = CreatePhysicObject((Vector2){ screenWidth*0.25f, screenHeight/2 }, 0.0f, (Vector2){ 75, 50 });
+ PhysicObject rectangle = CreatePhysicObject((Vector2){ screenWidth*0.25f, screenHeight/2 }, 0.0f, (Vector2){ 75, 50 });
rectangle->rigidbody.enabled = true; // Enable physic object rigidbody behaviour
rectangle->rigidbody.applyGravity = true;
rectangle->rigidbody.friction = 0.1f;
rectangle->rigidbody.bounciness = 6.0f;
// Create square physic object
- PhysicObject *square = CreatePhysicObject((Vector2){ screenWidth*0.75f, screenHeight/2 }, 0.0f, (Vector2){ 50, 50 });
+ PhysicObject square = CreatePhysicObject((Vector2){ screenWidth*0.75f, screenHeight/2 }, 0.0f, (Vector2){ 50, 50 });
square->rigidbody.enabled = true; // Enable physic object rigidbody behaviour
square->rigidbody.applyGravity = true;
square->rigidbody.friction = 0.1f;
// Create walls physic objects
- PhysicObject *floor = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.95f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
- PhysicObject *leftWall = CreatePhysicObject((Vector2){ 0.0f, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
- PhysicObject *rightWall = CreatePhysicObject((Vector2){ screenWidth, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
- PhysicObject *roof = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.05f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
+ PhysicObject floor = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.95f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
+ PhysicObject leftWall = CreatePhysicObject((Vector2){ 0.0f, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
+ PhysicObject rightWall = CreatePhysicObject((Vector2){ screenWidth, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
+ PhysicObject roof = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.05f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
// Create pplatform physic object
- PhysicObject *platform = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.7f }, 0.0f, (Vector2){ screenWidth*0.25f, 20 });
+ PhysicObject platform = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.7f }, 0.0f, (Vector2){ screenWidth*0.25f, 20 });
//--------------------------------------------------------------------------------------
@@ -114,7 +114,8 @@ int main()
// De-Initialization
//--------------------------------------------------------------------------------------
- ClosePhysics(); // Unitialize physics module
+ ClosePhysics(); // Unitialize physics (including all loaded objects)
+
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
diff --git a/examples/physics_forces.c b/examples/physics_forces.c
index 74b40d57..f4eefa05 100644
--- a/examples/physics_forces.c
+++ b/examples/physics_forces.c
@@ -17,7 +17,7 @@
#define LINE_LENGTH 75
#define TRIANGLE_LENGTH 12
-void DrawRigidbodyCircle(PhysicObject *obj, Color color);
+void DrawRigidbodyCircle(PhysicObject obj, Color color);
int main()
{
@@ -36,7 +36,7 @@ int main()
bool isDebug = false;
// Create rectangle physic objects
- PhysicObject *rectangles[3];
+ PhysicObject rectangles[3];
for (int i = 0; i < 3; i++)
{
rectangles[i] = CreatePhysicObject((Vector2){ screenWidth/4*(i+1), (((i % 2) == 0) ? (screenHeight/3) : (screenHeight/1.5f)) }, 0.0f, (Vector2){ 50, 50 });
@@ -46,7 +46,7 @@ int main()
// Create circles physic objects
// NOTE: when creating circle physic objects, transform.scale must be { 0, 0 } and object radius must be defined in collider.radius and use this value to draw the circle.
- PhysicObject *circles[3];
+ PhysicObject circles[3];
for (int i = 0; i < 3; i++)
{
circles[i] = CreatePhysicObject((Vector2){ screenWidth/4*(i+1), (((i % 2) == 0) ? (screenHeight/1.5f) : (screenHeight/4)) }, 0.0f, (Vector2){ 0, 0 });
@@ -57,10 +57,10 @@ int main()
}
// Create walls physic objects
- PhysicObject *leftWall = CreatePhysicObject((Vector2){ -25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
- PhysicObject *rightWall = CreatePhysicObject((Vector2){ screenWidth + 25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
- PhysicObject *topWall = CreatePhysicObject((Vector2){ screenWidth/2, -25 }, 0.0f, (Vector2){ screenWidth, 50 });
- PhysicObject *bottomWall = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight + 25 }, 0.0f, (Vector2){ screenWidth, 50 });
+ PhysicObject leftWall = CreatePhysicObject((Vector2){ -25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
+ PhysicObject rightWall = CreatePhysicObject((Vector2){ screenWidth + 25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
+ PhysicObject topWall = CreatePhysicObject((Vector2){ screenWidth/2, -25 }, 0.0f, (Vector2){ screenWidth, 50 });
+ PhysicObject bottomWall = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight + 25 }, 0.0f, (Vector2){ screenWidth, 50 });
//--------------------------------------------------------------------------------------
diff --git a/examples/resources/shaders/glsl100/bloom.fs b/examples/resources/shaders/glsl100/bloom.fs
index 5a08843d..280d2fb6 100644
--- a/examples/resources/shaders/glsl100/bloom.fs
+++ b/examples/resources/shaders/glsl100/bloom.fs
@@ -33,5 +33,5 @@ void main()
else if (texelColor.r < 0.5) tc = sum*sum*0.009 + texelColor;
else tc = sum*sum*0.0075 + texelColor;
- finalColor = tc;
+ gl_FragColor = tc;
} \ No newline at end of file
diff --git a/examples/resources/shaders/glsl100/swirl.fs b/examples/resources/shaders/glsl100/swirl.fs
index e77d4f87..0d6d24f2 100644
--- a/examples/resources/shaders/glsl100/swirl.fs
+++ b/examples/resources/shaders/glsl100/swirl.fs
@@ -20,7 +20,7 @@ float angle = 0.8;
uniform vec2 center = vec2(200.0, 200.0);
-void main (void)
+void main()
{
vec2 texSize = vec2(renderWidth, renderHeight);
vec2 tc = fragTexCoord*texSize;
diff --git a/examples/resources/shaders/glsl330/bloom.fs b/examples/resources/shaders/glsl330/bloom.fs
index 47ddee30..0307bc06 100644
--- a/examples/resources/shaders/glsl330/bloom.fs
+++ b/examples/resources/shaders/glsl330/bloom.fs
@@ -17,7 +17,7 @@ void main()
{
vec4 sum = vec4(0);
vec4 tc = vec4(0);
-
+
for (int i = -4; i < 4; i++)
{
for (int j = -3; j < 3; j++)
diff --git a/examples/resources/shaders/glsl330/phong.fs b/examples/resources/shaders/glsl330/phong.fs
deleted file mode 100644
index 80e3d673..00000000
--- a/examples/resources/shaders/glsl330/phong.fs
+++ /dev/null
@@ -1,82 +0,0 @@
-#version 330
-
-// Input vertex attributes (from vertex shader)
-in vec2 fragTexCoord;
-in vec3 fragNormal;
-
-// Input uniform values
-uniform sampler2D texture0;
-uniform vec4 fragTintColor;
-
-// Output fragment color
-out vec4 finalColor;
-
-// NOTE: Add here your custom variables
-
-// Light uniform values
-uniform vec3 lightAmbientColor = vec3(0.6, 0.3, 0.0);
-uniform vec3 lightDiffuseColor = vec3(1.0, 0.5, 0.0);
-uniform vec3 lightSpecularColor = vec3(0.0, 1.0, 0.0);
-uniform float lightIntensity = 1.0;
-uniform float lightSpecIntensity = 1.0;
-
-// Material uniform values
-uniform vec3 matAmbientColor = vec3(1.0, 1.0, 1.0);
-uniform vec3 matSpecularColor = vec3(1.0, 1.0, 1.0);
-uniform float matGlossiness = 50.0;
-
-// World uniform values
-uniform vec3 lightPosition;
-uniform vec3 cameraPosition;
-
-// Calculate ambient lighting component
-vec3 AmbientLighting()
-{
- return (matAmbientColor*lightAmbientColor);
-}
-
-// Calculate diffuse lighting component
-vec3 DiffuseLighting(in vec3 N, in vec3 L)
-{
- // Lambertian reflection calculation
- float diffuse = clamp(dot(N, L), 0, 1);
-
- return (fragTintColor.xyz*lightDiffuseColor*lightIntensity*diffuse);
-}
-
-// Calculate specular lighting component
-vec3 SpecularLighting(in vec3 N, in vec3 L, in vec3 V)
-{
- float specular = 0.0;
-
- // Calculate specular reflection only if the surface is oriented to the light source
- if (dot(N, L) > 0)
- {
- // Calculate half vector
- vec3 H = normalize(L + V);
-
- // Calculate specular intensity
- specular = pow(dot(N, H), 3 + matGlossiness);
- }
-
- return (matSpecularColor*lightSpecularColor*lightSpecIntensity*specular);
-}
-
-void main()
-{
- // Normalize input vectors
- vec3 L = normalize(lightPosition);
- vec3 V = normalize(cameraPosition);
- vec3 N = normalize(fragNormal);
-
- // Calculate lighting components
- vec3 ambient = AmbientLighting();
- vec3 diffuse = DiffuseLighting(N, L);
- vec3 specular = SpecularLighting(N, L, V);
-
- // Texel color fetching from texture sampler
- vec4 texelColor = texture(texture0, fragTexCoord);
-
- // Calculate final fragment color
- finalColor = vec4(texelColor.rgb*(ambient + diffuse + specular), texelColor.a);
-} \ No newline at end of file
diff --git a/examples/resources/shaders/glsl330/phong.vs b/examples/resources/shaders/glsl330/phong.vs
deleted file mode 100644
index d68d9b3f..00000000
--- a/examples/resources/shaders/glsl330/phong.vs
+++ /dev/null
@@ -1,29 +0,0 @@
-#version 330
-
-// Input vertex attributes
-in vec3 vertexPosition;
-in vec2 vertexTexCoord;
-in vec3 vertexNormal;
-
-// Input uniform values
-uniform mat4 mvpMatrix;
-
-// Output vertex attributes (to fragment shader)
-out vec2 fragTexCoord;
-out vec3 fragNormal;
-
-// NOTE: Add here your custom variables
-uniform mat4 modelMatrix;
-
-void main()
-{
- // Send vertex attributes to fragment shader
- fragTexCoord = vertexTexCoord;
-
- // Calculate view vector normal from model
- mat3 normalMatrix = transpose(inverse(mat3(modelMatrix)));
- fragNormal = normalize(normalMatrix*vertexNormal);
-
- // Calculate final vertex position
- gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
-} \ No newline at end of file
diff --git a/examples/resources/shaders/glsl330/swirl.fs b/examples/resources/shaders/glsl330/swirl.fs
index da098754..80c16cc9 100644
--- a/examples/resources/shaders/glsl330/swirl.fs
+++ b/examples/resources/shaders/glsl330/swirl.fs
@@ -21,7 +21,7 @@ float angle = 0.8;
uniform vec2 center = vec2(200.0, 200.0);
-void main (void)
+void main()
{
vec2 texSize = vec2(renderWidth, renderHeight);
vec2 tc = fragTexCoord*texSize;
diff --git a/examples/resources/shaders/standard.fs b/examples/resources/shaders/standard.fs
new file mode 100644
index 00000000..3c3bef4b
--- /dev/null
+++ b/examples/resources/shaders/standard.fs
@@ -0,0 +1,136 @@
+#version 330
+
+in vec3 fragPosition;
+in vec2 fragTexCoord;
+in vec4 fragColor;
+in vec3 fragNormal;
+
+out vec4 finalColor;
+
+uniform sampler2D texture0;
+
+uniform vec4 colAmbient;
+uniform vec4 colDiffuse;
+uniform vec4 colSpecular;
+uniform float glossiness;
+
+uniform mat4 modelMatrix;
+uniform vec3 viewDir;
+
+struct Light {
+ int enabled;
+ int type;
+ vec3 position;
+ vec3 direction;
+ vec4 diffuse;
+ float intensity;
+ float attenuation;
+ float coneAngle;
+};
+
+const int maxLights = 8;
+uniform int lightsCount;
+uniform Light lights[maxLights];
+
+vec3 CalcPointLight(Light l, vec3 n, vec3 v)
+{
+ vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
+ vec3 surfaceToLight = l.position - surfacePos;
+
+ // Diffuse shading
+ float brightness = clamp(dot(n, surfaceToLight)/(length(surfaceToLight)*length(n)), 0, 1);
+ float diff = 1.0/dot(surfaceToLight/l.attenuation, surfaceToLight/l.attenuation)*brightness*l.intensity;
+
+ // Specular shading
+ float spec = 0.0;
+ if (diff > 0.0)
+ {
+ vec3 h = normalize(-l.direction + v);
+ spec = pow(dot(n, h), 3 + glossiness);
+ }
+
+ return (diff*l.diffuse.rgb*colDiffuse.rgb + spec*colSpecular.rgb);
+}
+
+vec3 CalcDirectionalLight(Light l, vec3 n, vec3 v)
+{
+ vec3 lightDir = normalize(-l.direction);
+
+ // Diffuse shading
+ float diff = clamp(dot(n, lightDir), 0.0, 1.0)*l.intensity;
+
+ // Specular shading
+ float spec = 0.0;
+ if (diff > 0.0)
+ {
+ vec3 h = normalize(lightDir + v);
+ spec = pow(dot(n, h), 3 + glossiness);
+ }
+
+ // Combine results
+ return (diff*l.intensity*l.diffuse.rgb*colDiffuse.rgb + spec*colSpecular.rgb);
+}
+
+vec3 CalcSpotLight(Light l, vec3 n, vec3 v)
+{
+ vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
+ vec3 lightToSurface = normalize(surfacePos - l.position);
+ vec3 lightDir = normalize(-l.direction);
+
+ // Diffuse shading
+ float diff = clamp(dot(n, lightDir), 0.0, 1.0)*l.intensity;
+
+ // Spot attenuation
+ float attenuation = clamp(dot(n, lightToSurface), 0.0, 1.0);
+ attenuation = dot(lightToSurface, -lightDir);
+ float lightToSurfaceAngle = degrees(acos(attenuation));
+ if (lightToSurfaceAngle > l.coneAngle) attenuation = 0.0;
+ float falloff = (l.coneAngle - lightToSurfaceAngle)/l.coneAngle;
+
+ // Combine diffuse and attenuation
+ float diffAttenuation = diff*attenuation;
+
+ // Specular shading
+ float spec = 0.0;
+ if (diffAttenuation > 0.0)
+ {
+ vec3 h = normalize(lightDir + v);
+ spec = pow(dot(n, h), 3 + glossiness);
+ }
+
+ return falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb);
+}
+
+void main()
+{
+ // Calculate fragment normal in screen space
+ mat3 normalMatrix = transpose(inverse(mat3(modelMatrix)));
+ vec3 normal = normalize(normalMatrix*fragNormal);
+
+ // Normalize normal and view direction vectors
+ vec3 n = normalize(normal);
+ vec3 v = normalize(viewDir);
+
+ // Calculate diffuse texture color fetching
+ vec4 texelColor = texture(texture0, fragTexCoord);
+ vec3 lighting = colAmbient.rgb;
+
+ for (int i = 0; i < lightsCount; i++)
+ {
+ // Check if light is enabled
+ if (lights[i].enabled == 1)
+ {
+ // Calculate lighting based on light type
+ switch (lights[i].type)
+ {
+ case 0: lighting += CalcPointLight(lights[i], n, v); break;
+ case 1: lighting += CalcDirectionalLight(lights[i], n, v); break;
+ case 2: lighting += CalcSpotLight(lights[i], n, v); break;
+ default: break;
+ }
+ }
+ }
+
+ // Calculate final fragment color
+ finalColor = vec4(texelColor.rgb*lighting, texelColor.a);
+}
diff --git a/examples/resources/shaders/standard.vs b/examples/resources/shaders/standard.vs
new file mode 100644
index 00000000..fc0a5ff4
--- /dev/null
+++ b/examples/resources/shaders/standard.vs
@@ -0,0 +1,23 @@
+#version 330
+
+in vec3 vertexPosition;
+in vec3 vertexNormal;
+in vec2 vertexTexCoord;
+in vec4 vertexColor;
+
+out vec3 fragPosition;
+out vec2 fragTexCoord;
+out vec4 fragColor;
+out vec3 fragNormal;
+
+uniform mat4 mvpMatrix;
+
+void main()
+{
+ fragPosition = vertexPosition;
+ fragTexCoord = vertexTexCoord;
+ fragColor = vertexColor;
+ fragNormal = vertexNormal;
+
+ gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
+} \ No newline at end of file
diff --git a/examples/shaders_basic_lighting.c b/examples/shaders_basic_lighting.c
deleted file mode 100644
index d72eb417..00000000
--- a/examples/shaders_basic_lighting.c
+++ /dev/null
@@ -1,171 +0,0 @@
-/*******************************************************************************************
-*
-* raylib [shaders] example - Basic lighting: Blinn-Phong
-*
-* This example has been created using raylib 1.3 (www.raylib.com)
-* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-* Copyright (c) 2014 Ramon Santamaria (@raysan5)
-*
-********************************************************************************************/
-
-#include "raylib.h"
-
-#define SHININESS_SPEED 1.0f
-#define LIGHT_SPEED 0.25f
-
-// Light type
-typedef struct Light {
- Vector3 position;
- Vector3 direction;
- float intensity;
- float specIntensity;
- Color diffuse;
- Color ambient;
- Color specular;
-} Light;
-
-int main()
-{
- // Initialization
- //--------------------------------------------------------------------------------------
- const int screenWidth = 800;
- const int screenHeight = 450;
-
- SetConfigFlags(FLAG_MSAA_4X_HINT);
- InitWindow(screenWidth, screenHeight, "raylib [shaders] example - basic lighting");
-
- // Camera initialization
- Camera camera = {{ 8.0f, 8.0f, 8.0f }, { 0.0f, 3.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
-
- // Model initialization
- Vector3 position = { 0.0f, 0.0f, 0.0f };
- Model model = LoadModel("resources/model/dwarf.obj");
- Shader shader = LoadShader("resources/shaders/glsl330/phong.vs", "resources/shaders/glsl330/phong.fs");
- SetModelShader(&model, shader);
-
- // Shader locations initialization
- int lIntensityLoc = GetShaderLocation(shader, "lightIntensity");
- int lAmbientLoc = GetShaderLocation(shader, "lightAmbientColor");
- int lDiffuseLoc = GetShaderLocation(shader, "lightDiffuseColor");
- int lSpecularLoc = GetShaderLocation(shader, "lightSpecularColor");
- int lSpecIntensityLoc = GetShaderLocation(shader, "lightSpecIntensity");
-
- int mAmbientLoc = GetShaderLocation(shader, "matAmbientColor");
- int mSpecularLoc = GetShaderLocation(shader, "matSpecularColor");
- int mGlossLoc = GetShaderLocation(shader, "matGlossiness");
-
- // Camera and light vectors shader locations
- int cameraLoc = GetShaderLocation(shader, "cameraPosition");
- int lightLoc = GetShaderLocation(shader, "lightPosition");
-
- // Model and View matrix locations (required for lighting)
- int modelLoc = GetShaderLocation(shader, "modelMatrix");
- //int viewLoc = GetShaderLocation(shader, "viewMatrix"); // Not used
-
- // Light and material definitions
- Light light;
- Material matBlinn;
-
- // Light initialization
- light.position = (Vector3){ 4.0f, 2.0f, 0.0f };
- light.direction = (Vector3){ 5.0f, 1.0f, 1.0f };
- light.intensity = 1.0f;
- light.diffuse = WHITE;
- light.ambient = (Color){ 150, 75, 0, 255 };
- light.specular = WHITE;
- light.specIntensity = 1.0f;
-
- // Material initialization
- matBlinn.colDiffuse = WHITE;
- matBlinn.colAmbient = (Color){ 50, 50, 50, 255 };
- matBlinn.colSpecular = WHITE;
- matBlinn.glossiness = 50.0f;
-
- // Setup camera
- SetCameraMode(CAMERA_FREE); // Set camera mode
- SetCameraPosition(camera.position); // Set internal camera position to match our camera position
- SetCameraTarget(camera.target); // Set internal camera target to match our camera target
-
- SetTargetFPS(60);
- //--------------------------------------------------------------------------------------
-
- // Main game loop
- while (!WindowShouldClose()) // Detect window close button or ESC key
- {
- // Update
- //----------------------------------------------------------------------------------
- UpdateCamera(&camera); // Update camera position
-
- // NOTE: Model transform can be set in model.transform or directly with params at draw... WATCH OUT!
- SetShaderValueMatrix(shader, modelLoc, model.transform); // Send model matrix to shader
- //SetShaderValueMatrix(shader, viewLoc, GetCameraMatrix(camera)); // Not used
-
- // Glossiness input control
- if(IsKeyDown(KEY_UP)) matBlinn.glossiness += SHININESS_SPEED;
- else if(IsKeyDown(KEY_DOWN))
- {
- matBlinn.glossiness -= SHININESS_SPEED;
- if( matBlinn.glossiness < 0) matBlinn.glossiness = 0.0f;
- }
-
- // Light X movement
- if (IsKeyDown(KEY_D)) light.position.x += LIGHT_SPEED;
- else if(IsKeyDown(KEY_A)) light.position.x -= LIGHT_SPEED;
-
- // Light Y movement
- if (IsKeyDown(KEY_LEFT_SHIFT)) light.position.y += LIGHT_SPEED;
- else if (IsKeyDown(KEY_LEFT_CONTROL)) light.position.y -= LIGHT_SPEED;
-
- // Light Z movement
- if (IsKeyDown(KEY_S)) light.position.z += LIGHT_SPEED;
- else if (IsKeyDown(KEY_W)) light.position.z -= LIGHT_SPEED;
-
- // Send light values to shader
- SetShaderValue(shader, lIntensityLoc, &light.intensity, 1);
- SetShaderValue(shader, lAmbientLoc, ColorToFloat(light.ambient), 3);
- SetShaderValue(shader, lDiffuseLoc, ColorToFloat(light.diffuse), 3);
- SetShaderValue(shader, lSpecularLoc, ColorToFloat(light.specular), 3);
- SetShaderValue(shader, lSpecIntensityLoc, &light.specIntensity, 1);
-
- // Send material values to shader
- SetShaderValue(shader, mAmbientLoc, ColorToFloat(matBlinn.colAmbient), 3);
- SetShaderValue(shader, mSpecularLoc, ColorToFloat(matBlinn.colSpecular), 3);
- SetShaderValue(shader, mGlossLoc, &matBlinn.glossiness, 1);
-
- // Send camera and light transform values to shader
- SetShaderValue(shader, cameraLoc, VectorToFloat(camera.position), 3);
- SetShaderValue(shader, lightLoc, VectorToFloat(light.position), 3);
- //----------------------------------------------------------------------------------
-
- // Draw
- //----------------------------------------------------------------------------------
- BeginDrawing();
-
- ClearBackground(RAYWHITE);
-
- Begin3dMode(camera);
-
- DrawModel(model, position, 4.0f, matBlinn.colDiffuse);
- DrawSphere(light.position, 0.5f, GOLD);
-
- DrawGrid(20, 1.0f);
-
- End3dMode();
-
- DrawFPS(10, 10); // Draw FPS
-
- EndDrawing();
- //----------------------------------------------------------------------------------
- }
-
- // De-Initialization
- //--------------------------------------------------------------------------------------
- UnloadShader(shader);
- UnloadModel(model);
-
- CloseWindow(); // Close window and OpenGL context
- //--------------------------------------------------------------------------------------
-
- return 0;
-}
diff --git a/examples/shaders_standard_lighting.c b/examples/shaders_standard_lighting.c
new file mode 100644
index 00000000..7a9cc086
--- /dev/null
+++ b/examples/shaders_standard_lighting.c
@@ -0,0 +1,118 @@
+/*******************************************************************************************
+*
+* raylib [shaders] example - Standard lighting (materials and lights)
+*
+* NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
+* OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
+*
+* NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
+* on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
+* raylib comes with shaders ready for both versions, check raylib/shaders install folder
+*
+* This example has been created using raylib 1.3 (www.raylib.com)
+* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+* Copyright (c) 2016 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+#include "raymath.h"
+
+int main()
+{
+ // Initialization
+ //--------------------------------------------------------------------------------------
+ int screenWidth = 800;
+ int screenHeight = 450;
+
+ SetConfigFlags(FLAG_MSAA_4X_HINT); // Enable Multi Sampling Anti Aliasing 4x (if available)
+
+ InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader");
+
+ // Define the camera to look into our 3d world
+ Camera camera = {{ 4.0f, 4.0f, 4.0f }, { 0.0f, 1.5f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
+ Vector3 position = { 0.0f, 0.0f, 0.0f }; // Set model position
+
+ Model dwarf = LoadModel("resources/model/dwarf.obj"); // Load OBJ model
+ Texture2D texDiffuse = LoadTexture("resources/model/dwarf_diffuse.png"); // Load model diffuse texture
+
+ Material material = LoadStandardMaterial();
+ material.texDiffuse = texDiffuse;
+ material.colDiffuse = (Color){255, 255, 255, 255};
+ material.colAmbient = (Color){0, 0, 10, 255};
+ material.colSpecular = (Color){255, 255, 255, 255};
+ material.glossiness = 50.0f;
+ dwarf.material = material; // Apply material to model
+
+ Light spotLight = CreateLight(LIGHT_SPOT, (Vector3){3.0f, 5.0f, 2.0f}, (Color){255, 255, 255, 255});
+ spotLight->target = (Vector3){0.0f, 0.0f, 0.0f};
+ spotLight->intensity = 2.0f;
+ spotLight->diffuse = (Color){255, 100, 100, 255};
+ spotLight->coneAngle = 60.0f;
+
+ Light dirLight = CreateLight(LIGHT_DIRECTIONAL, (Vector3){0.0f, -3.0f, -3.0f}, (Color){255, 255, 255, 255});
+ dirLight->target = (Vector3){1.0f, -2.0f, -2.0f};
+ dirLight->intensity = 2.0f;
+ dirLight->diffuse = (Color){100, 255, 100, 255};
+
+ Light pointLight = CreateLight(LIGHT_POINT, (Vector3){0.0f, 4.0f, 5.0f}, (Color){255, 255, 255, 255});
+ pointLight->intensity = 2.0f;
+ pointLight->diffuse = (Color){100, 100, 255, 255};
+ pointLight->attenuation = 3.0f;
+
+ // Setup orbital camera
+ SetCameraMode(CAMERA_ORBITAL); // Set a orbital camera mode
+ SetCameraPosition(camera.position); // Set internal camera position to match our camera position
+ SetCameraTarget(camera.target); // Set internal camera target to match our camera target
+
+ SetTargetFPS(60); // Set our game to run at 60 frames-per-second
+ //--------------------------------------------------------------------------------------
+
+ // Main game loop
+ while (!WindowShouldClose()) // Detect window close button or ESC key
+ {
+ // Update
+ //----------------------------------------------------------------------------------
+ UpdateCamera(&camera); // Update internal camera and our camera
+ //----------------------------------------------------------------------------------
+
+ // Draw
+ //----------------------------------------------------------------------------------
+ BeginDrawing();
+
+ ClearBackground(RAYWHITE);
+
+ Begin3dMode(camera);
+
+ DrawModel(dwarf, position, 2.0f, WHITE); // Draw 3d model with texture
+
+ DrawLights(); // Draw all created lights in 3D world
+
+ DrawGrid(10, 1.0f); // Draw a grid
+
+ End3dMode();
+
+ DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY);
+
+ DrawFPS(10, 10);
+
+ EndDrawing();
+ //----------------------------------------------------------------------------------
+ }
+
+ // De-Initialization
+ //--------------------------------------------------------------------------------------
+ UnloadMaterial(material); // Unload material and assigned textures
+ UnloadModel(dwarf); // Unload model
+
+ // Destroy all created lights
+ DestroyLight(pointLight);
+ DestroyLight(dirLight);
+ DestroyLight(spotLight);
+
+ CloseWindow(); // Close window and OpenGL context
+ //--------------------------------------------------------------------------------------
+
+ return 0;
+} \ No newline at end of file
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-11 14:16:53 +0000