#include "raylib.h" #include "raymath.h" // Required for: Vector3, Quaternion and Matrix functionality #include "utils.h" // Required for: TRACELOG(), LoadFileData(), LoadFileText(), SaveFileText() #include #include #include "../libvitaboy/libvitaboy.hpp" #define SCREEN_WIDTH (800) #define SCREEN_HEIGHT (600) #define WINDOW_TITLE "libvitaboy - Renderer - Ray" //we dont look in this mess for now #pragma region TSO //util static bool Read(const char* Filename, uint8_t** InData) { *InData = File::ReadFile(Filename); if (*InData != NULL) { VBFile.set(*InData, File::FileSize); return true; } return false; } //globals //skeleton static Skeleton_t Skeleton; static Model box_model; static void DrawBonesSkeleton(Bone_t& Bone, const Matrix& M) { Vector3 axis{ Vector3Zero()}; float angle{ 0 }; const Quaternion rotation = Quaternion{ Bone.Rotation.x, Bone.Rotation.y, Bone.Rotation.z, Bone.Rotation.w }; QuaternionToAxisAngle(rotation, &axis, &angle); // A normalized quaternion(called a "versor") consisting of X, Y, Z, W coordinates, each a 32 - bit little - endian float, // specifying the default rotation of this bone to be applied after translation. Matrix matRotation = MatrixRotate(axis, angle * DEG2RAD); // X,Y,Z coordinates, each a 32-bit little-endian float, // specifying the distance from the joint with the parent to the distal end of this bone after the default rotation has been applied Matrix matTranslation = MatrixTranslate(Bone.Translation.x, Bone.Translation.y, Bone.Translation.z); Matrix matTransform = MatrixMultiply(matTranslation, matRotation); Matrix modelMatrix = MatrixMultiply(M, matTranslation); Color color; if(!strcmp(Bone.Name, "ROOT")) { color = RED; } else if(!strcmp(Bone.Name, "HEAD")) { color = YELLOW; } else { color = GREEN; } const Vector3 position{ modelMatrix.m12, modelMatrix.m13, modelMatrix.m14 }; DrawModel(box_model, position, 1.f, color); if (Bone.ChildrenCount == 1) { DrawBonesSkeleton(*Bone.Children[0], M); } else if (Bone.ChildrenCount > 1) { for (unsigned i = 0; i < Bone.ChildrenCount; i++) { DrawBonesSkeleton(*Bone.Children[i], modelMatrix); } } } static int counter = 0; static void DrawTest(const Matrix& M) { Vector3 scale = { 1.f, 1.f, 1.f }; Vector3 rotationAxis = { 0.0f, 0.0f, 1.0f }; Matrix matScale = MatrixScale(scale.x, scale.y, scale.z); Matrix matRotation = MatrixRotate(rotationAxis, 45.f * DEG2RAD); Matrix matTranslation = MatrixTranslate(5.f, 0.f, 0.f); //transform 5 in the X direction // https://github.com/JipBoesenkool/CSE167F17_Project4/blob/master/src/renderer/model/Transform.cpp // SRT = iTRS, for absolute // STR = iRTS, for local transforms Matrix matTransform = MatrixMultiply(MatrixMultiply(matScale, matTranslation), matRotation); Matrix modelMatrix = MatrixMultiply(matTransform, M); DrawModel (box_model, //root Vector3Transform(Vector3{ 0.f, 0.f, 0.f }, modelMatrix), 1.f, YELLOW); DrawModel(box_model, //x Vector3Transform(Vector3{ 1.f, 0.f, 0.f }, modelMatrix), 1.f, RED); DrawModel(box_model, //y Vector3Transform(Vector3{ 0.f, 1.f, 0.f }, modelMatrix), 1.f, GREEN); DrawModel(box_model, //z Vector3Transform(Vector3{ 0.f, 0.f, 1.f }, modelMatrix), 1.f, BLUE); if (counter < 3) { counter++; DrawTest(modelMatrix); } counter = 0; } //animation static Animation_t Animation; static float AnimationTime = 0; static void AdvanceFrame(Skeleton_t& Skeleton, Animation_t& Animation, float TimeDelta) { float Duration = (float)Animation.Motions[0].FrameCount/30; AnimationTime += TimeDelta; AnimationTime = fmodf(AnimationTime, Duration); //Loop the animation for(unsigned i=0; i 1) { for (unsigned i = 0; i < Bone.ChildrenCount; i++) { TransformVertices(*Bone.Children[i], matTransform); } } } static void BlendVertices() { for (unsigned i = 0; i < MeshCount; i++) { Mesh_t& Mesh = Meshes[i]; for (unsigned i = 0; i < Mesh.BlendVertexCount; i++) { Vertex_t& BlendVertex = Mesh.TransformedVertexData[Mesh.RealVertexCount + i]; float Weight = BlendVertex.BlendData.Weight; Vertex_t& RealVertex = Mesh.TransformedVertexData[BlendVertex.BlendData.OtherVertex]; RealVertex.Coord.x = Weight * BlendVertex.Coord.x + (1 - Weight) * RealVertex.Coord.x; RealVertex.Coord.y = Weight * BlendVertex.Coord.y + (1 - Weight) * RealVertex.Coord.y; RealVertex.Coord.z = Weight * BlendVertex.Coord.z + (1 - Weight) * RealVertex.Coord.z; } } } #pragma endregion TSO #pragma region custom_ray namespace CustomRay { static Model LoadModelTSO() { Model model; //meshes model.meshCount = MeshCount; model.meshes = (Mesh*)RL_CALLOC(model.meshCount, sizeof(Mesh)); //textures model.materialCount = 3; model.meshMaterial = (int*)RL_CALLOC(model.meshCount, sizeof(int)); // Material index assigned to each mesh model.materials = (Material*)RL_CALLOC(model.materialCount, sizeof(Material)); model.meshMaterial[0] = 0; // By default, assign material 0 to each mesh ///load the textures for (int i = 0; i < model.materialCount; i++) { model.materials[i] = LoadMaterialDefault(); model.materials[i].maps[MATERIAL_MAP_DIFFUSE].texture = textures[i]; } //load meshes for (int i = 0; i < model.meshCount; i++) { Mesh_t& tso_mesh = Meshes[i]; Mesh& ray_mesh = model.meshes[i]; ray_mesh.vertexCount = tso_mesh.RealVertexCount; ray_mesh.triangleCount = tso_mesh.FaceCount; // Face count (triangulated) ray_mesh.vertices = (float*)RL_CALLOC(ray_mesh.vertexCount * 3, sizeof(float)); ray_mesh.texcoords = (float*)RL_CALLOC(ray_mesh.vertexCount * 2, sizeof(float)); ray_mesh.normals = (float*)RL_CALLOC(ray_mesh.vertexCount * 3, sizeof(float)); ray_mesh.indices = (unsigned short*)RL_CALLOC(ray_mesh.triangleCount * 3, sizeof(unsigned short)); // Process all mesh faces //vertex data for (unsigned j = 0; j < ray_mesh.vertexCount; j++) { //vertices? ray_mesh.vertices[j * 3 + 0] = tso_mesh.TransformedVertexData[j].Coord.x; ray_mesh.vertices[j * 3 + 1] = tso_mesh.TransformedVertexData[j].Coord.y; ray_mesh.vertices[j * 3 + 2] = tso_mesh.TransformedVertexData[j].Coord.z; //ray_mesh.vertices[j * 3 + 0] = tso_mesh.VertexData[j].Coord.x; //ray_mesh.vertices[j * 3 + 1] = tso_mesh.VertexData[j].Coord.y; //ray_mesh.vertices[j * 3 + 2] = tso_mesh.VertexData[j].Coord.z + (i * 1.f); //offset for now so we can see them //coords ray_mesh.texcoords[j * 2 + 0] = tso_mesh.TransformedVertexData[j].TextureCoord.u; ray_mesh.texcoords[j * 2 + 1] = -tso_mesh.TransformedVertexData[j].TextureCoord.v; //normals ray_mesh.normals[j * 3 + 0] = tso_mesh.TransformedVertexData[j].NormalCoord.x; ray_mesh.normals[j * 3 + 0] = tso_mesh.TransformedVertexData[j].NormalCoord.y; ray_mesh.normals[j * 3 + 0] = tso_mesh.TransformedVertexData[j].NormalCoord.z; } //indices for (unsigned j = 0; j < ray_mesh.triangleCount; j++) { ray_mesh.indices[j * 3 + 0] = (unsigned short)tso_mesh.FaceData[j].VertexA; //counter clock wise ray_mesh.indices[j * 3 + 1] = (unsigned short)tso_mesh.FaceData[j].VertexC; ray_mesh.indices[j * 3 + 2] = (unsigned short)tso_mesh.FaceData[j].VertexB; //Clock wise //ray_mesh.indices[j * 3 + 1] = (unsigned short)tso_mesh.FaceData[j].VertexB; //ray_mesh.indices[j * 3 + 2] = (unsigned short)tso_mesh.FaceData[j].VertexC; } //select the textures model.meshMaterial[i] = Mesh_UseTexture[i]; } //upload to gpu // Make sure model transform is set to identity matrix! model.transform = MatrixIdentity(); if ((model.meshCount != 0) && (model.meshes != NULL)) { // Upload vertex data to GPU (static meshes) for (int i = 0; i < model.meshCount; i++) UploadMesh(&model.meshes[i], false); } else TRACELOG(LOG_WARNING, "MESH: [%s] Failed to load model mesh(es) data", fileName); if (model.materialCount == 0) { TRACELOG(LOG_WARNING, "MATERIAL: [%s] Failed to load model material data, default to white material", fileName); model.materialCount = 1; model.materials = (Material*)RL_CALLOC(model.materialCount, sizeof(Material)); model.materials[0] = LoadMaterialDefault(); if (model.meshMaterial == NULL) { model.meshMaterial = (int*)RL_CALLOC(model.meshCount, sizeof(int)); } } return model; } ModelAnimation LoadModelAnimationsTSO() { ModelAnimation result; // Translation data - For each translation: // Translation - X, Y, Z coordinates, each a 32 - bit little - endian float, specifying new, // REPLACEMENT translation values for the bones of the skeleton.These values are stored absolute. // Rotation data - For each rotation : // Rotation - A normalized quaternion(called a "versor") consisting of X, Y, Z, W coordinates, each a 32 - bit little - endian float, specifying new, // replacement rotation values for the bones of the skeleton.These values are stored absolute. // These values assume a left - handed coordinate system, meaning that for a right - handed coordinate system(like OpenGL and XNA), you have to mirror the quaternion by negating Y and Z. return result; } //https://gist.github.com/Gamerfiend/18206474679bf5873925c839d0d6a6d0 void LoadSkeletonTSO(Model& ray_model) { //Load the bonus // map string to ID Skeleton_t& tso_skeleton = Skeleton; const unsigned int boneCount = Skeleton.BoneCount; ray_model.boneCount = boneCount; ray_model.bones = (BoneInfo*)RL_MALLOC(boneCount * sizeof(BoneInfo)); ray_model.bindPose = (Transform*)RL_MALLOC(boneCount * sizeof(Transform)); for (unsigned int i = 0; i < Skeleton.BoneCount; i++) { Bone_t& tso_bone = Skeleton.Bones[i]; BoneInfo& ray_bone = ray_model.bones[i]; Transform& ray_bone_transform = ray_model.bindPose[i]; //fill boneinfo //sims naming might be bigger then 32 chars, assert if so const int length = strlen(tso_bone.Name); assert(strlen(tso_bone.Name) <= 32); strcpy(ray_bone.name, tso_bone.Name); ray_bone.parent = FindBone(Skeleton, tso_bone.ParentsName, boneCount); printf("Bone: %i\n", i); printf("Name: %s\n", ray_bone.name); printf("parentName: %s\n", tso_bone.ParentsName); printf("parentID: %i\n", ray_bone.parent); // Set the transform const Translation_t& tso_bone_position = tso_bone.Translation; const Rotation_t& tso_bone_rotation = tso_bone.Rotation; const Vector3 tso_bone_Scale = { 1.f, 1.f, 1.f, }; //no scale? // sucks writing it out, but safer then pointer casting //position ray_bone_transform.translation.x = tso_bone_position.x; ray_bone_transform.translation.y = tso_bone_position.y; ray_bone_transform.translation.z = tso_bone_position.z; //rotation ray_bone_transform.rotation.x = tso_bone_rotation.x; ray_bone_transform.rotation.y = tso_bone_rotation.y; ray_bone_transform.rotation.z = tso_bone_rotation.z; ray_bone_transform.rotation.w = tso_bone_rotation.w; //scale ray_bone_transform.scale.x = tso_bone_Scale.x; ray_bone_transform.scale.y = tso_bone_Scale.y; ray_bone_transform.scale.z = tso_bone_Scale.z; } for (int i = 0; i < ray_model.meshCount; i++) { Mesh_t& tso_mesh = Meshes[i]; Mesh& ray_mesh = ray_model.meshes[i]; } [[maybe_unused]] unsigned int block = 0; block++; } } #pragma endregion custom_ray static int Startup() { uint8_t * InData; if(!Read("skeleton.skel", &InData)) return 0; ReadSkeleton(Skeleton); free(InData); for(unsigned i=0; i