From d3497d36dad7a5416623b29ca3c031b6a59db80e Mon Sep 17 00:00:00 2001 From: unklnik Date: Sat, 30 Sep 2023 21:01:10 +0200 Subject: [PATCH] updated light.go added basic lighting example --- examples/shaders/basic_lighting/light.go | 76 +++++++++++++++ examples/shaders/basic_lighting/lighting.fs | 82 ++++++++++++++++ examples/shaders/basic_lighting/lighting.vs | 32 ++++++ examples/shaders/basic_lighting/main.go | 103 ++++++++++++++++++++ examples/shaders/mesh_instancing/light.go | 20 +--- 5 files changed, 295 insertions(+), 18 deletions(-) create mode 100644 examples/shaders/basic_lighting/light.go create mode 100644 examples/shaders/basic_lighting/lighting.fs create mode 100644 examples/shaders/basic_lighting/lighting.vs create mode 100644 examples/shaders/basic_lighting/main.go diff --git a/examples/shaders/basic_lighting/light.go b/examples/shaders/basic_lighting/light.go new file mode 100644 index 0000000..055fe26 --- /dev/null +++ b/examples/shaders/basic_lighting/light.go @@ -0,0 +1,76 @@ +package main + +import ( + "fmt" + "unsafe" + + rl "github.com/gen2brain/raylib-go/raylib" +) + +type LightType int32 + +const ( + LightTypeDirectional LightType = iota + LightTypePoint +) + +type Light struct { + shader rl.Shader + lightType LightType + position rl.Vector3 + target rl.Vector3 + color rl.Color + enabled int32 + // shader locations + enabledLoc int32 + typeLoc int32 + posLoc int32 + targetLoc int32 + colorLoc int32 +} + +const maxLightsCount = 4 + +var lightCount = 0 + +func NewLight( + lightType LightType, + position, target rl.Vector3, + color rl.Color, + shader rl.Shader) Light { + light := Light{ + shader: shader, + } + if lightCount < maxLightsCount { + light.enabled = 1 + light.lightType = lightType + light.position = position + light.target = target + light.color = color + light.enabledLoc = rl.GetShaderLocation(shader, fmt.Sprintf("lights[%d].enabled", lightCount)) + light.typeLoc = rl.GetShaderLocation(shader, fmt.Sprintf("lights[%d].type", lightCount)) + light.posLoc = rl.GetShaderLocation(shader, fmt.Sprintf("lights[%d].position", lightCount)) + light.targetLoc = rl.GetShaderLocation(shader, fmt.Sprintf("lights[%d].target", lightCount)) + light.colorLoc = rl.GetShaderLocation(shader, fmt.Sprintf("lights[%d].color", lightCount)) + light.UpdateValues() + lightCount++ + } + return light +} + +func (lt *Light) UpdateValues() { + // Send to shader light enabled state and type + rl.SetShaderValue(lt.shader, lt.enabledLoc, unsafe.Slice((*float32)(unsafe.Pointer(<.enabled)), 4), rl.ShaderUniformInt) + rl.SetShaderValue(lt.shader, lt.typeLoc, unsafe.Slice((*float32)(unsafe.Pointer(<.lightType)), 4), rl.ShaderUniformInt) + + // Send to shader light position values + rl.SetShaderValue(lt.shader, lt.posLoc, []float32{lt.position.X, lt.position.Y, lt.position.Z}, rl.ShaderUniformVec3) + + // Send to shader light target target values + rl.SetShaderValue(lt.shader, lt.targetLoc, []float32{lt.target.X, lt.target.Y, lt.target.Z}, rl.ShaderUniformVec3) + + // Send to shader light color values + rl.SetShaderValue(lt.shader, lt.colorLoc, + []float32{float32(lt.color.R) / 255, float32(lt.color.G) / 255, float32(lt.color.B) / 255, float32(lt.color.A) / 255}, + rl.ShaderUniformVec4) +} diff --git a/examples/shaders/basic_lighting/lighting.fs b/examples/shaders/basic_lighting/lighting.fs new file mode 100644 index 0000000..58845c8 --- /dev/null +++ b/examples/shaders/basic_lighting/lighting.fs @@ -0,0 +1,82 @@ +#version 330 + +// Input vertex attributes (from vertex shader) +in vec3 fragPosition; +in vec2 fragTexCoord; +//in vec4 fragColor; +in vec3 fragNormal; + +// Input uniform values +uniform sampler2D texture0; +uniform vec4 colDiffuse; + +// Output fragment color +out vec4 finalColor; + +// NOTE: Add here your custom variables + +#define MAX_LIGHTS 4 +#define LIGHT_DIRECTIONAL 0 +#define LIGHT_POINT 1 + +struct MaterialProperty { + vec3 color; + int useSampler; + sampler2D sampler; +}; + +struct Light { + int enabled; + int type; + vec3 position; + vec3 target; + vec4 color; +}; + +// Input lighting values +uniform Light lights[MAX_LIGHTS]; +uniform vec4 ambient; +uniform vec3 viewPos; + +void main() +{ + // Texel color fetching from texture sampler + vec4 texelColor = texture(texture0, fragTexCoord); + vec3 lightDot = vec3(0.0); + vec3 normal = normalize(fragNormal); + vec3 viewD = normalize(viewPos - fragPosition); + vec3 specular = vec3(0.0); + + // NOTE: Implement here your fragment shader code + + for (int i = 0; i < MAX_LIGHTS; i++) + { + if (lights[i].enabled == 1) + { + vec3 light = vec3(0.0); + + if (lights[i].type == LIGHT_DIRECTIONAL) + { + light = -normalize(lights[i].target - lights[i].position); + } + + if (lights[i].type == LIGHT_POINT) + { + light = normalize(lights[i].position - fragPosition); + } + + float NdotL = max(dot(normal, light), 0.0); + lightDot += lights[i].color.rgb*NdotL; + + float specCo = 0.0; + if (NdotL > 0.0) specCo = pow(max(0.0, dot(viewD, reflect(-(light), normal))), 16.0); // 16 refers to shine + specular += specCo; + } + } + + finalColor = (texelColor*((colDiffuse + vec4(specular, 1.0))*vec4(lightDot, 1.0))); + finalColor += texelColor*(ambient/10.0)*colDiffuse; + + // Gamma correction + finalColor = pow(finalColor, vec4(1.0/2.2)); +} diff --git a/examples/shaders/basic_lighting/lighting.vs b/examples/shaders/basic_lighting/lighting.vs new file mode 100644 index 0000000..f8ec45f --- /dev/null +++ b/examples/shaders/basic_lighting/lighting.vs @@ -0,0 +1,32 @@ +#version 330 + +// Input vertex attributes +in vec3 vertexPosition; +in vec2 vertexTexCoord; +in vec3 vertexNormal; +in vec4 vertexColor; + +// Input uniform values +uniform mat4 mvp; +uniform mat4 matModel; +uniform mat4 matNormal; + +// Output vertex attributes (to fragment shader) +out vec3 fragPosition; +out vec2 fragTexCoord; +out vec4 fragColor; +out vec3 fragNormal; + +// NOTE: Add here your custom variables + +void main() +{ + // Send vertex attributes to fragment shader + fragPosition = vec3(matModel*vec4(vertexPosition, 1.0)); + fragTexCoord = vertexTexCoord; + fragColor = vertexColor; + fragNormal = normalize(vec3(matNormal*vec4(vertexNormal, 1.0))); + + // Calculate final vertex position + gl_Position = mvp*vec4(vertexPosition, 1.0); +} diff --git a/examples/shaders/basic_lighting/main.go b/examples/shaders/basic_lighting/main.go new file mode 100644 index 0000000..a65b4cb --- /dev/null +++ b/examples/shaders/basic_lighting/main.go @@ -0,0 +1,103 @@ +package main + +import ( + rl "github.com/gen2brain/raylib-go/raylib" +) + +func main() { + screenWidth := int32(1280) + screenHeight := int32(720) + + rl.SetConfigFlags(rl.FlagMsaa4xHint) //ENABLE 4X MSAA IF AVAILABLE + + rl.InitWindow(screenWidth, screenHeight, "raylib [shaders] example - basic lighting") + + camera := rl.Camera{} + camera.Position = rl.NewVector3(2.0, 4.0, 6.0) + camera.Target = rl.NewVector3(0.0, 0.5, 0.0) + camera.Up = rl.NewVector3(0.0, 1.0, 0.0) + camera.Fovy = 45.0 + camera.Projection = rl.CameraPerspective + + ground := rl.LoadModelFromMesh(rl.GenMeshPlane(10, 10, 3, 3)) + cube := rl.LoadModelFromMesh(rl.GenMeshCube(2, 4, 2)) + + shader := rl.LoadShader("lighting.vs", "lighting.fs") + + *shader.Locs = rl.GetShaderLocation(shader, "viewPos") + + ambientLoc := rl.GetShaderLocation(shader, "ambient") + shaderValue := []float32{0.1, 0.1, 0.1, 1.0} + rl.SetShaderValue(shader, ambientLoc, shaderValue, rl.ShaderUniformVec4) + + ground.Materials.Shader = shader + cube.Materials.Shader = shader + + lights := make([]Light, 4) + lights[0] = NewLight(LightTypePoint, rl.NewVector3(-2, 1, -2), rl.NewVector3(0, 0, 0), rl.Yellow, shader) + + lights[1] = NewLight(LightTypePoint, rl.NewVector3(2, 1, 2), rl.NewVector3(0, 0, 0), rl.Red, shader) + + lights[2] = NewLight(LightTypePoint, rl.NewVector3(-2, 1, 2), rl.NewVector3(0, 0, 0), rl.Green, shader) + + lights[3] = NewLight(LightTypePoint, rl.NewVector3(2, 1, -2), rl.NewVector3(0, 0, 0), rl.Blue, shader) + + rl.SetTargetFPS(60) + + for !rl.WindowShouldClose() { + rl.UpdateCamera(&camera, rl.CameraOrbital) + + cameraPos := []float32{camera.Position.X, camera.Position.Y, camera.Position.Z} + rl.SetShaderValue(shader, *shader.Locs, cameraPos, rl.ShaderUniformVec3) + + if rl.IsKeyPressed(rl.KeyY) { + lights[0].enabled *= -1 + } + if rl.IsKeyPressed(rl.KeyR) { + lights[1].enabled *= -1 + } + if rl.IsKeyPressed(rl.KeyG) { + lights[2].enabled *= -1 + } + if rl.IsKeyPressed(rl.KeyB) { + lights[3].enabled *= -1 + } + + for i := 0; i < len(lights); i++ { + lights[i].UpdateValues() + } + + rl.BeginDrawing() + + rl.ClearBackground(rl.RayWhite) + + rl.BeginMode3D(camera) + + rl.DrawModel(ground, rl.NewVector3(0, 0, 0), 1, rl.White) + rl.DrawModel(cube, rl.NewVector3(0, 0, 0), 1, rl.White) + + for i := 0; i < len(lights); i++ { + if lights[i].enabled == 1 { + rl.DrawSphereEx(lights[i].position, 0.2, 8, 8, lights[i].color) + } else { + rl.DrawSphereWires(lights[i].position, 0.2, 8, 8, rl.Fade(lights[i].color, 0.3)) + } + } + + rl.DrawGrid(10, 1.0) // Draw a grid + + rl.EndMode3D() + + rl.DrawFPS(10, 10) + + rl.DrawText("KEYS [Y] [R] [G] [B] TURN LIGHTS ON/OFF", 10, 40, 20, rl.Black) + + rl.EndDrawing() + } + + rl.UnloadShader(shader) // Unload shader + rl.UnloadModel(cube) // Unload model + rl.UnloadModel(ground) // Unload model + + rl.CloseWindow() +} diff --git a/examples/shaders/mesh_instancing/light.go b/examples/shaders/mesh_instancing/light.go index b38aae2..055fe26 100644 --- a/examples/shaders/mesh_instancing/light.go +++ b/examples/shaders/mesh_instancing/light.go @@ -2,7 +2,6 @@ package main import ( "fmt" - "reflect" "unsafe" rl "github.com/gen2brain/raylib-go/raylib" @@ -22,7 +21,6 @@ type Light struct { target rl.Vector3 color rl.Color enabled int32 - // shader locations enabledLoc int32 typeLoc int32 @@ -40,46 +38,32 @@ func NewLight( position, target rl.Vector3, color rl.Color, shader rl.Shader) Light { - light := Light{ shader: shader, } - if lightCount < maxLightsCount { light.enabled = 1 light.lightType = lightType light.position = position light.target = target light.color = color - light.enabledLoc = rl.GetShaderLocation(shader, fmt.Sprintf("lights[%d].enabled", lightCount)) light.typeLoc = rl.GetShaderLocation(shader, fmt.Sprintf("lights[%d].type", lightCount)) light.posLoc = rl.GetShaderLocation(shader, fmt.Sprintf("lights[%d].position", lightCount)) light.targetLoc = rl.GetShaderLocation(shader, fmt.Sprintf("lights[%d].target", lightCount)) light.colorLoc = rl.GetShaderLocation(shader, fmt.Sprintf("lights[%d].color", lightCount)) light.UpdateValues() - lightCount++ } - return light } -// Send light properties to shader func (lt *Light) UpdateValues() { - // not pretty -_- - // need nicer api - sh := &reflect.SliceHeader{ - Len: 4, - Cap: 4, - } - // Send to shader light enabled state and type - sh.Data = uintptr(unsafe.Pointer(<.enabled)) - rl.SetShaderValue(lt.shader, lt.enabledLoc, *(*[]float32)(unsafe.Pointer(sh)), rl.ShaderUniformInt) + rl.SetShaderValue(lt.shader, lt.enabledLoc, unsafe.Slice((*float32)(unsafe.Pointer(<.enabled)), 4), rl.ShaderUniformInt) + rl.SetShaderValue(lt.shader, lt.typeLoc, unsafe.Slice((*float32)(unsafe.Pointer(<.lightType)), 4), rl.ShaderUniformInt) // Send to shader light position values - sh.Data = uintptr(unsafe.Pointer(<.lightType)) rl.SetShaderValue(lt.shader, lt.posLoc, []float32{lt.position.X, lt.position.Y, lt.position.Z}, rl.ShaderUniformVec3) // Send to shader light target target values