/// <summary> /// Map overview render. /// </summary> public override void RenderForMap() { if (GenBlockShadows) { if (!Visible || model.Meshes.Count == 0) { return; } model.DrawLOD(GetPosition() + ClientUtilities.ConvertD(transform.ExtractTranslation()), TheClient.MainWorldView); } }
/// <summary> /// prepare matrices for rendering /// TODO: Optimize calcs only when dirty /// </summary> /// <param name="viewproj"></param> /// <param name="parentmodel"></param> public void CalculateDrawMatrices(Matrix4d viewproj, Matrix4d parentmodel) { WorldTransform = transform.GetMatrix() * parentmodel; transform.WorldPosition = WorldTransform.ExtractTranslation(); mvp = MTransform.GetFloatMatrix(WorldTransform * viewproj); modelMatrix = MTransform.GetFloatMatrix(WorldTransform); }
Vector3d GetQuantizedPoint(Vector3d p, Vector3d origin, double xrot, double yrot) { Vector3d delta = p - origin; Matrix4d rotx = Matrix4d.CreateFromQuaternion( Quaterniond.FromEulerAngles(xrot * Math.PI / 180.0, yrot * Math.PI / 180.0, 0) ); Matrix4d pos = Matrix4d.CreateTranslation(delta); Matrix4d result = pos * rotx; Vector3d vresult = result.ExtractTranslation() + origin; return(vresult); }
void processNode(Node node, Scene scene) { MAnimatedMesh mesh; for (int i = 0; i < scene.MeshCount; i++) { Mesh ai_mesh = scene.Meshes[i]; mesh = processMesh(ai_mesh, scene); Matrix4d tr = FromMatrixd(node.Transform); mesh.transform.Position = tr.ExtractTranslation(); mesh.transform.Rotation = tr.ExtractRotation(); mesh.transform.Scale = tr.ExtractScale(); mesh.AddMaterial(this.material); //Meshes.Add(mesh); //accumulate all meshes in one vector Add(mesh); } }
MMesh processMesh(Mesh mesh, Scene scene, string sName, Matrix4d trans) { // data to fill List <TexturedVertex> vertices = new List <TexturedVertex>(); List <int> indices = new List <int>(); List <MTexture> textures = new List <MTexture>(); // Walk through each of the mesh's vertices for (int i = 0; i < mesh.VertexCount; i++) { TexturedVertex vertex = new TexturedVertex(); Vector3 vector = new Vector3(); // we declare a placeholder vector since assimp uses its own vector class that doesn't directly convert to glm's vec3 class so we transfer the data to this placeholder glm::vec3 first. // positions vector.X = mesh.Vertices[i].X; vector.Y = mesh.Vertices[i].Y; vector.Z = mesh.Vertices[i].Z; vertex._position = vector; // normals if (mesh.HasNormals) { vector.X = mesh.Normals[i].X; vector.Y = mesh.Normals[i].Y; vector.Z = mesh.Normals[i].Z; vertex._normal = vector; } // texture coordinates if (mesh.HasTextureCoords(0)) // does the mesh contain texture coordinates? { Vector2 vec = new Vector2(); // a vertex can contain up to 8 different texture coordinates. We thus make the assumption that we won't // use models where a vertex can have multiple texture coordinates so we always take the first set (0). vec.X = mesh.TextureCoordinateChannels[0][i].X; vec.Y = 1 - mesh.TextureCoordinateChannels[0][i].Y; vertex._textureCoordinate = vec; } else { vertex._textureCoordinate = new Vector2(0.0f, 0.0f); } if (mesh.HasTangentBasis) { // tangent vector.X = mesh.Tangents[i].X; vector.Y = mesh.Tangents[i].Y; vector.Z = mesh.Tangents[i].Z; /// vertex.Tangent = vector; // bitangent vector.X = mesh.BiTangents[i].X; vector.Y = mesh.BiTangents[i].Y; vector.Z = mesh.BiTangents[i].Z; /// vertex.BiTangent = vector; } vertices.Add(vertex); } // now wak through each of the mesh's faces (a face is a mesh its triangle) and retrieve the corresponding vertex indices. for (int i = 0; i < mesh.FaceCount; i++) { Face face = mesh.Faces[i]; // retrieve all indices of the face and store them in the indices vector for (int j = 0; j < face.IndexCount; j++) { indices.Add(face.Indices[j]); } } // process materials Material material = scene.Materials[mesh.MaterialIndex]; // we assume a convention for sampler names in the shaders. Each diffuse texture should be named // as 'texture_diffuseN' where N is a sequential number ranging from 1 to MAX_SAMPLER_NUMBER. // Same applies to other texture as the following list summarizes: // diffuse: texture_diffuseN // specular: texture_specularN // normal: texture_normalN // 1. diffuse maps /* * List<MTexture> diffuseMaps = loadMaterialTextures(material, TextureType_DIFFUSE, "texture_diffuse"); * textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end()); * // 2. specular maps * List<Texture> specularMaps = loadMaterialTextures(material, aiTextureType_SPECULAR, "texture_specular"); * textures.insert(textures.end(), specularMaps.begin(), specularMaps.end()); * // 3. normal maps * List<Texture> normalMaps = loadMaterialTextures(material, aiTextureType_HEIGHT, "texture_normal"); * textures.insert(textures.end(), normalMaps.begin(), normalMaps.end()); * // 4. height maps * List<Texture> heightMaps = loadMaterialTextures(material, aiTextureType_AMBIENT, "texture_height"); * textures.insert(textures.end(), heightMaps.begin(), heightMaps.end()); */ // return a mesh object created from the extracted mesh data MMesh m = new MMesh(sName); // trans.Transpose(); m.transform.Position = trans.ExtractTranslation(); m.transform.Rotation = trans.ExtractRotation(); m.transform.Scale = trans.ExtractScale(); m.AddMaterial(this.material); m.SetupMesh(vertices, indices, textures); return(m); }