lost_soul

main.odin (6364B)

---

 package main
 
 import "core:c"
 import "core:fmt"
 import "core:math"
 import "core:math/rand"
 //import "vendor:miniaudio"
 import rl "vendor:raylib"
 
 velocity: f32 = 0.50
 velocity_speed: f32 = 1.0
 speed: f32 = 400
 
 SCREEN_WIDTH: c.int
 SCREEN_HEIGHT: c.int
 
 shader: rl.Shader
 camera: rl.Camera
 
 init :: proc() {
 	//rl.SetTraceLogLevel(.NONE)
 	rl.SetConfigFlags(
 		{
 			rl.ConfigFlag.WINDOW_RESIZABLE,
 			rl.ConfigFlag.VSYNC_HINT,
 			rl.ConfigFlag.BORDERLESS_WINDOWED_MODE,
 		},
 	)
 	rl.SetTraceLogLevel(rl.TraceLogLevel.ALL)
 	rl.SetTargetFPS(60)
 	rl.InitWindow(1024, 768, "Lost Soul")
 	SCREEN_WIDTH = rl.GetScreenWidth()
 	SCREEN_HEIGHT = rl.GetScreenHeight()
 	//monitor := rl.GetCurrentMonitor()
 	//rl.SetWindowSize(rl.GetMonitorWidth(monitor), rl.GetMonitorHeight(monitor))
 	rl.InitAudioDevice()
 }
 
 input :: proc(dt: f32) {
 	if rl.IsKeyDown(rl.KeyboardKey.TAB) {
 		rl.EnableCursor()
 	}
 
 	if rl.IsKeyDown(rl.KeyboardKey.ONE) {
 		rl.DisableCursor()
 	}
 
 	if rl.IsKeyPressed(rl.KeyboardKey.BACKSPACE) {
 		tmp := camera.target
 		pos := camera.position
 		fmt.println("TARGET: %v - %v - %v \n", tmp.x, tmp.y, tmp.z)
 		fmt.println("POSITION: %v - %v - %v \n", pos.xyz)
 	}
 
 	if rl.IsKeyDown(rl.KeyboardKey.LEFT_SHIFT) {
 		velocity *= velocity_speed * 2.0
 	}
 }
 
 setup_camera :: proc() {
 	camera.position = {-1.7414374, 2, 3.4975357} // Camera position
 	camera.target = {8.08, 5.36, 3.28} // Camera looking at point
 	camera.up = {0.0, 1.0, 0.0} // Camera up vector (rotation towards target)
 	camera.fovy = 90.0 // Camera field-of-view Y
 	camera.projection = rl.CameraProjection.PERSPECTIVE // Camera mode type
 	rl.DisableCursor()
 }
 
 draw_crosshair :: proc() {
 	rl.DrawCircle((SCREEN_WIDTH / 2) - 1, (SCREEN_HEIGHT / 2) - 1, 2, rl.WHITE)
 }
 
 window_resized :: proc() {
 	SCREEN_WIDTH = rl.GetScreenWidth()
 	SCREEN_HEIGHT = rl.GetScreenHeight()
 }
 
 main :: proc() {
 
 	init()
 
 	//perlin := rl.GenImagePerlinNoise(1000, 1000, 0, 0, 10)
 	//rl.ExportImage(perlin, "assets/textures/perlin.png")
 
 	//// Load from memory. very nice way
 	// foo := #load("assets/player/hooded.png")
 	// foo_img := rl.LoadImageFromMemory(".png", &foo[0], i32(len(foo)))
 	// player_ani := AnimationComponent{rl.LoadTextureFromImage(foo_img), false, 0.1, 0, 0}
 
 	//test := #load("common/teapot.obj")
 	music := #load("assets/music/o.mp3")
 	soilData := #load("assets/textures/soil.png")
 	soil_img := rl.LoadImageFromMemory(".png", &soilData[0], i32(len(soilData)))
 	soil := rl.LoadTextureFromImage(soil_img)
 	rl.UnloadImage(soil_img)
 	defer rl.UnloadTexture(soil)
 
 	kosniData := #load("assets/textures/kosni.png")
 	kosni_img := rl.LoadImageFromMemory(".png", &kosniData[0], i32(len(kosniData)))
 	rl.ImageRotate(&kosni_img, 180)
 	kosni := rl.LoadTextureFromImage(kosni_img)
 	rl.UnloadImage(kosni_img)
 	defer rl.UnloadTexture(kosni)
 
 	next_frame: u32 = 1
 	timer: f32 = 0
 
 	setup_camera()
 	model := rl.LoadModel("common/cow.obj") // Load model
 
 	audio := rl.LoadMusicStreamFromMemory(".mp3", &music[0], i32(len(music)))
 	rl.PlayMusicStream(audio)
 	rl.SetMusicVolume(audio, 0.2)
 	// audio := rl.LoadMusicStream("assets/music/o.wav")
 	// rl.PlayMusicStream(audio)
 
 	//terrainMesh: rl.Mesh = rl.GenMeshPlane(100, 100, 1, 1)
 	//fmt.println(terrainMesh.texcoords[:12])
 	for i: c.int = 0; i < 12; i += 1 {
 		//fmt.println(terrainMesh.vertexCount)
 		//terrainMesh.texcoords[i] *= 10
 	}
 	//terrainModel: rl.Model = rl.LoadModelFromMesh(terrainMesh)
 	//terrainModel: rl.Model = rl.LoadModelFromMesh(rl.GenMeshPlane(10, 10, 10, 10))
 	//terrainModel.materials[0].maps[rl.MaterialMapIndex.ALBEDO].texture = soil
 
 	tmp := rl.GenMeshCube(20, 20, 20)
 	cube: rl.Model = rl.LoadModelFromMesh(tmp)
 	cube.materials[0].maps[rl.MaterialMapIndex.ALBEDO].texture = kosni
 
 
 	// tmp := rl.LoadImage("assets/skybox/cubemap.png")
 	// cubemap: rl.TextureCubemap = rl.LoadTextureCubemap(tmp, rl.CubemapLayout.AUTO_DETECT)
 
 	// Skybox stuff
 	// Load skybox model
 	ccube := rl.GenMeshCube(1.0, 1.0, 1.0)
 	skybox := rl.LoadModelFromMesh(rl.GenMeshCube(1, 1, 1))
 
 	skybox.materials[0].shader = rl.LoadShader("shaders/skybox.vs", "shaders/skybox.fs")
 
 	//rl.SetShaderValue(
 	//	skybox.materials[0].shader,
 	//	rl.GetShaderLocation(skybox.materials[0].shader, "environmentMap"),
 	//	rawptr(uintptr(rl.MaterialMapIndex.CUBEMAP)),
 	//	rl.ShaderUniformDataType.INT,
 	//)
 
 	//rl.SetShaderValue(
 	//	skybox.materials[0].shader,
 	//	rl.GetShaderLocation(skybox.materials[0].shader, "doGamma"),
 	//	rawptr(uintptr(0)),
 	//	rl.ShaderUniformDataType.INT,
 	//)
 
 	// rl.SetShaderValue(
 	// 	skybox.materials[0].shader,
 	// 	rl.GetShaderLocation(skybox.materials[0].shader, "vflipped"),
 	// 	rawptr(uintptr(0)),
 	// 	rl.ShaderUniformDataType.INT,
 	// )
 
 	// Load cubemap shader and setup required shader locations
 	shdrCubemap := rl.LoadShader("shaders/cubemap.vs", "shaders/cubemap.fs")
 
 	//rl.SetShaderValue(
 	//	shdrCubemap,
 	//	rl.GetShaderLocation(shdrCubemap, "equirectangularMap"),
 	//	rawptr(uintptr(0)),
 	//	rl.ShaderUniformDataType.INT,
 	//)
 
 
 	// Create a RenderTexture2D to be used for render to texture
 	shader := rl.LoadShader(cstring(""), "shaders/blur.fs")
 	target := rl.LoadRenderTexture(1024, 768)
 
 	height_img := rl.LoadImage("assets/textures/perlin.png")
 	height_tex := rl.LoadTextureFromImage(height_img)
 	height := rl.GenMeshHeightmap(height_img, {20, 1, 20})
 	heightModel := rl.LoadModelFromMesh(height)
 
 	heightModel.materials[0].maps[rl.MaterialMapIndex.ALBEDO].texture = kosni
 	bd := rl.GetMeshBoundingBox(height)
 	mat := rl.LoadMaterialDefault()
 	ho := rl.GenMeshCube(5, 5, 5)
 
 	rl.SetMaterialTexture(&mat, rl.MaterialMapIndex.ALBEDO, soil)
 	instanceShader: rl.Shader = rl.LoadShader("", "shaders/instance.vs")
 
 	matrices := [dynamic]rl.Matrix{rl.MatrixIdentity()}
 
 	for !rl.WindowShouldClose() {
 
 		if (rl.IsWindowResized()) {
 			window_resized()
 		}
 
 		frame_counter := rl.GetFrameTime()
 
 		input(frame_counter)
 
 		rl.UpdateMusicStream(audio)
 
 		rl.UpdateCamera(&camera, rl.CameraMode.FIRST_PERSON)
 
 		rl.BeginDrawing()
 
 		rl.ClearBackground({33, 33, 33, 255})
 
 		rl.BeginMode3D(camera)
 
 		//rl.DrawCubeWires({0, 0, 0}, 20, 20, 20, rl.YELLOW)
 
 		//rl.DrawMesh(ho, mat, rl.MatrixIdentity())
 		rl.DrawMeshInstanced(ho, mat, raw_data(matrices[:]), 1)
 
 		rl.DrawModelWires(heightModel, {-8.0, 0, -8.0}, 1, rl.BLACK)
 
 		rl.EndMode3D()
 
 		draw_crosshair()
 
 		rl.DrawFPS(5, 5)
 
 		rl.EndDrawing()
 	}
 
 	rl.CloseWindow()
 	rl.CloseAudioDevice()
 }