/// <summary> /// The main Process method converts an intermediate format content pipeline /// NodeContent tree to a ModelContent object with embedded animation data. /// </summary> public override ModelContent Process(NodeContent input, ContentProcessorContext context) { ValidateMesh(input, context, null); // Find the skeleton. BoneContent skeleton = MeshHelper.FindSkeleton(input); if (skeleton == null) { throw new InvalidContentException("Input skeleton not found."); } // We don't want to have to worry about different parts of the model being // in different local coordinate systems, so let's just bake everything. FlattenTransforms(input, skeleton); // Read the bind pose and skeleton hierarchy data. IList <BoneContent> bones = MeshHelper.FlattenSkeleton(skeleton); if (bones.Count > SkinnedEffect.MaxBones) { throw new InvalidContentException(string.Format( "Skeleton has {0} bones, but the maximum supported is {1}.", bones.Count, SkinnedEffect.MaxBones)); } List <Matrix> bindPose = new List <Matrix>(); List <Matrix> inverseBindPose = new List <Matrix>(); List <int> skeletonHierarchy = new List <int>(); foreach (BoneContent bone in bones) { bindPose.Add(bone.Transform); inverseBindPose.Add(Matrix.Invert(bone.AbsoluteTransform)); skeletonHierarchy.Add(bones.IndexOf(bone.Parent as BoneContent)); } // Convert animation data to our runtime format. Dictionary <string, AnimationClip> animationClips; animationClips = ProcessAnimations(skeleton.Animations, bones); // Chain to the base ModelProcessor class so it can convert the model data. ModelContent model = base.Process(input, context); // Store our custom animation data in the Tag property of the model. model.Tag = new SkinningData(animationClips, bindPose, inverseBindPose, skeletonHierarchy); return(model); }
private void InitializeFloorAsphalt() { float l = spaceSize; float h = 0f; VertexData[] vertices = new VertexData[] { new VertexData { Position = new Vector3(-l, h, -l), Normal = Vector3.Up, Texture = new Vector2(0.0f, 0.0f) }, new VertexData { Position = new Vector3(-l, h, +l), Normal = Vector3.Up, Texture = new Vector2(0.0f, 1.0f) }, new VertexData { Position = new Vector3(+l, h, -l), Normal = Vector3.Up, Texture = new Vector2(1.0f, 0.0f) }, new VertexData { Position = new Vector3(+l, h, +l), Normal = Vector3.Up, Texture = new Vector2(1.0f, 1.0f) }, }; uint[] indices = new uint[] { 0, 1, 2, 1, 3, 2, }; MaterialContent mat = MaterialContent.Default; mat.DiffuseTexture = "SceneLights/floors/asphalt/d_road_asphalt_stripes_diffuse.dds"; mat.NormalMapTexture = "SceneLights/floors/asphalt/d_road_asphalt_stripes_normal.dds"; mat.SpecularTexture = "SceneLights/floors/asphalt/d_road_asphalt_stripes_specular.dds"; var content = ModelContent.GenerateTriangleList(vertices, indices, mat); var desc = new ModelDescription() { Name = "Floor", Static = true, CastShadow = true, DeferredEnabled = true, DepthEnabled = true, AlphaEnabled = false, UseAnisotropicFiltering = true, Content = new ContentDescription() { ModelContent = content } }; this.AddComponent <Model>(desc); }
private AnimationClips ProcessAnimations(ModelContent model, NodeContent input, ContentProcessorContext context) { //first build a lookup table so we can determine the index into the list of bones from a bone name for (int i = 0; i < model.Bones.Count; i++) { bones[model.Bones[i].Name] = i; } AnimationClips animationClips = new AnimationClips(); ProcessAnimationRecursive(input, animationClips); return(animationClips); }
public override TOutput Process(TInput input, ContentProcessorContext context) { // play with this later //foreach (MD5Submesh submesh in input.Submeshes) //{ // TextureContent l = context.BuildAndLoadAsset<TextureContent, TextureContent>(new ExternalReference<TextureContent>(submesh.Shader), "TextureProcessor"); // submesh.TextureContent = l; //} ModelContent model = MD5CapsuleContent.CreateCapsule(Vector3.Forward * 30f + Vector3.Up * 30f, Vector3.Forward * -30f + Vector3.Up * 30f, Vector3.Right, 20f, context); input.CapsuleContent = model; return(input); }
/// <summary> /// Calculate a bounding box for the model. /// </summary> /// <param name="model">The model to calculate AABBs for</param> public static void CalculateBounding(NodeContent input, ModelContent model) { BoundingBox box = new BoundingBox(); BoundingSphere sphere = new BoundingSphere(); CalculateBounding(input, ref box, ref sphere); if (model.Tag == null) { model.Tag = new Dictionary <string, object>(); } (model.Tag as Dictionary <string, object>).Add("BoundingBox", box); (model.Tag as Dictionary <string, object>).Add("BoundingSphere", sphere); }
public override ModelContent Process(NodeContent input, ContentProcessorContext context) { var animationProcessor = new AnimationsProcessor(); animationProcessor.MaxBones = this.MaxBones; animationProcessor.GenerateKeyframesFrequency = this.GenerateKeyframesFrequency; animationProcessor.FixRealBoneRoot = this._fixRealBoneRoot; var animation = animationProcessor.Process(input, context); ModelContent model = base.Process(input, context); model.Tag = animation; return(model); }
public override ModelContent Process(NodeContent input, ContentProcessorContext context) { AnimatedModelData animatedModelData = ExtractSkeletonAndAnimations(input, context); Dictionary <string, object> dictionary = new Dictionary <string, object> { { "AnimatedModelData", animatedModelData } }; ModelContent modelContent = base.Process(input, context); modelContent.Tag = dictionary; return(modelContent); }
public override ModelContent Process(NodeContent input, ContentProcessorContext context) { ModelContent model = base.Process(input, context); foreach (var mesh in model.Meshes) { foreach (var part in mesh.MeshParts) { Proccess(part); } } return(model); }
// Function to process a model from normal content to a model with animation data public override ModelContent Process(NodeContent input, ContentProcessorContext context) { SetSkinnedEffect(input); BoneContent skeleton = ImportSkeleton(input); model = base.Process(input, context); AnimationDataImport(model, input, context); model.Tag = animationData; return(model); }
/// <summary> /// Initialize skeleton data /// </summary> /// <param name="modelContent">Model content</param> /// <param name="joint">Joint to initialize</param> /// <param name="animations">Animation list to feed</param> private static JointAnimation[] InitializeJoints(ModelContent modelContent, Joint joint, string[] skinController) { List <JointAnimation> animations = new List <JointAnimation>(); List <JointAnimation> boneAnimations = new List <JointAnimation>(); //Find keyframes for current bone var c = FindJointKeyframes(joint.Name, modelContent.Animations); if (c != null && c.Length > 0) { //Set bones Array.ForEach(c, (a) => { boneAnimations.Add(new JointAnimation(a.Joint, a.Keyframes)); }); } if (boneAnimations.Count > 0) { //Only one bone animation (for now) animations.Add(boneAnimations[0]); } foreach (string controllerName in skinController) { var controller = modelContent.Controllers[controllerName]; Matrix ibm = Matrix.Identity; if (controller.InverseBindMatrix.ContainsKey(joint.Name)) { ibm = controller.InverseBindMatrix[joint.Name]; } joint.Offset = ibm; } if (joint.Childs?.Length > 0) { foreach (var child in joint.Childs) { var ja = InitializeJoints(modelContent, child, skinController); animations.AddRange(ja); } } return(animations.ToArray()); }
public ActionResult ThemMoi() { IEnumerable <DropdownModel> category = _services.Dropdownlist(0, null, "CHUYENMUCDAOTAO", 1); ViewBag.contentParentId = category.Select(x => new SelectListItem { Text = x.Text, Value = x.Value.ToString() }); var model = new ModelContent { contentId = 0 }; return(View(model)); }
public override HeightMapInfoContent Process(Texture2DContent input, ContentProcessorContext context) { MeshBuilder meshBuilder = MeshBuilder.StartMesh("terrain"); input.ConvertBitmapType(typeof(PixelBitmapContent <float>)); PixelBitmapContent <float> item = (PixelBitmapContent <float>)input.Mipmaps[0]; for (int i = 0; i < item.Height; i++) { for (int j = 0; j < item.Width; j++) { Vector3 width = new Vector3( mScale * (j - (item.Width - 1) / 2f), width.Y = (item.GetPixel(j, i) - 1f) * Bumpiness, width.Z = mScale * (i - (item.Height - 1) / 2f) ); meshBuilder.CreatePosition(width); } } BasicMaterialContent basicMaterialContent = new BasicMaterialContent(); basicMaterialContent.SpecularColor = new Vector3(0.4f, 0.4f, 0.4f); if (!string.IsNullOrEmpty(TerrainTexture)) { string directoryName = Path.GetDirectoryName(input.Identity.SourceFilename); string str = Path.Combine(directoryName, TerrainTexture); basicMaterialContent.Texture = new ExternalReference <TextureContent>(str); } meshBuilder.SetMaterial(basicMaterialContent); int num = meshBuilder.CreateVertexChannel <Vector2>(VertexChannelNames.TextureCoordinate(0)); int num1 = 0; while (num1 < item.Height - 1) { for (int k = 0; k < item.Width - 1; k++) { AddVertex(meshBuilder, num, item.Width, k, num1); AddVertex(meshBuilder, num, item.Width, k + 1, num1); AddVertex(meshBuilder, num, item.Width, k + 1, num1 + 1); AddVertex(meshBuilder, num, item.Width, k, num1); AddVertex(meshBuilder, num, item.Width, k + 1, num1 + 1); AddVertex(meshBuilder, num, item.Width, k, num1 + 1); } num1++; } MeshContent meshContent = meshBuilder.FinishMesh(); ModelContent modelContent = context.Convert <MeshContent, ModelContent>(meshContent, "ModelProcessor"); return(new HeightMapInfoContent(modelContent, meshContent, mScale, item.Width, item.Height)); }
public override ModelContent Process(NodeContent node, ContentProcessorContext context) { ModelContent model = base.Process(node, context); ProcessChildren(node); int i = 0; foreach (ModelMeshContent mesh in model.Meshes) { mesh.Tag = information[i++]; } return(model); }
public override ModelContent Process(NodeContent input, ContentProcessorContext context) { CalculateTangentFrames(input, context); ModelContent modelContent = base.Process(input, context); foreach (ModelMeshContent modelMesh in modelContent.Meshes) { foreach (ModelMeshPartContent modelMeshPart in modelMesh.MeshParts) { modelMeshPart.Tag = modelMeshPart.Material.Name; } } return(modelContent); }
/// <summary> /// The function to process a model from original content into model content for export /// </summary> /// <param name="input"></param> /// <param name="context"></param> /// <returns></returns> public override ModelContent Process(NodeContent input, ContentProcessorContext context) { // Process the skeleton for skinned character animation BoneContent skeleton = ProcessSkeleton(input); SwapSkinnedMaterial(input); model = base.Process(input, context); ProcessAnimations(model, input, context); // Add the extra content to the model model.Tag = modelExtra; return(model); }
public override ModelContent Process(NodeContent input, ContentProcessorContext context) { foundSkinning_ = false; if (!forceShader_.Equals("") || !forceSkinnedShader_.Equals("")) { ReplaceShaders(input, context, input.Identity); } ModelContent ret = base.Process(input, context); if (ret.Tag == null) { ret.Tag = new Dictionary <string, object>(); } SetTexturePaths(ret); return(ret); }
//ModelContent modelContent = null; //static bool m_First = true; public override ModelContent Process(NodeContent input, ContentProcessorContext context) { bool collapsed = BokuPipeline.MaterialsGroup.PreProcess(input); // stash our model content so that we can use it to look up meshes // ModelContent model = base.Process(input, context); FindBBoxesRecurse(input, model); BokuPipeline.MaterialsGroup.TagMeshParts(model, collapsed); /* * // Just debug foo, nothing to see here. * foreach (ModelMeshContent mesh in model.Meshes) * { * foreach (ModelMeshPartContent part in mesh.MeshParts) * { * MaterialContent mat = part.Material; * float alpha = mat.OpaqueData.GetValue<float>("Alpha", -1.0f); * Vector3 diffuse = mat.OpaqueData.GetValue<Vector3>("DiffuseColor", -Vector3.One); * if(alpha != 1.0f) * { * } * } * } */ return(model); //NodeContentCollection ncc = input.Children; //parseChildren(ncc); //ModelContent mc2 = base.Process(input, context); //mc2.Meshes[0].MeshParts[0]; //int nMeshes = mc2.Meshes.Count; //BoundingBox[] boxes = new BoundingBox[nMeshes]; //for(int i = 0; i < nMeshes; i++) //{ // boxes[i] = GetBoundingBox(mc2.Meshes[i]); //} //return m_ModelContent; }
public override ModelContent Process(NodeContent input, ContentProcessorContext context) { List <Vector3> lowestPoints = new List <Vector3>(); lowestPoints = FindLowestPoints(input, lowestPoints); ModelContent model = base.Process(input, context); int i = 0; foreach (ModelMeshContent mesh in model.Meshes) { mesh.Tag = lowestPoints[i++]; } return(model); }
public override ModelContent Process(NodeContent input, ContentProcessorContext context) { ModelContent model = base.Process(input, context); foreach (ModelMeshContent mm in model.Meshes) { sphereList.Add(mm.BoundingSphere); } foreach (BoundingSphere bs in sphereList) { master = BoundingSphere.CreateMerged(master, bs); } sphereList.Insert(0, master); model.Tag = sphereList; return(model); }
private SkinInfoContentCollection[] ProcessSkinInfo(ModelContent model) { SkinInfoContentCollection[] info = new SkinInfoContentCollection[model.Meshes.Count]; Dictionary <string, int> boneDict = new Dictionary <string, int>(); foreach (ModelBoneContent b in model.Bones) { if (b.Name != null && !boneDict.ContainsKey(b.Name)) { boneDict.Add(b.Name, b.Index); } } for (int i = 0; i < info.Length; i++) { info[i] = new SkinInfoContentCollection(); BoneIndexer indexer = indexers[i]; ReadOnlyCollection <string> skinnedBoneNames = indexer.SkinnedBoneNames; Matrix[] absoluteTransforms = new Matrix[model.Bones.Count]; CalculateAbsoluteTransforms(model.Bones[0], absoluteTransforms); Matrix absoluteMeshTransform; if (absoluteMeshTransforms == null) { absoluteMeshTransform = absoluteTransforms[model.Meshes[i].ParentBone.Index]; } else { absoluteMeshTransform = absoluteMeshTransforms[i]; } for (int j = 0; j < skinnedBoneNames.Count; j++) { string name = skinnedBoneNames[j]; SkinInfoContent content = new SkinInfoContent(); content.BoneIndex = boneDict[name]; content.PaletteIndex = indexer.GetBoneIndex(name); content.InverseBindPoseTransform = absoluteMeshTransform * Matrix.Invert(absoluteTransforms[boneDict[name]]); content.BoneName = name; info[i].Add(content); } } return(info); }
private void InitializeFloor() { float l = 10f; float h = 0f; VertexData[] vertices = new VertexData[] { new VertexData { Position = new Vector3(-l, -h, -l), Normal = Vector3.Up, Texture = new Vector2(0.0f, 0.0f) }, new VertexData { Position = new Vector3(-l, -h, +l), Normal = Vector3.Up, Texture = new Vector2(0.0f, l) }, new VertexData { Position = new Vector3(+l, -h, -l), Normal = Vector3.Up, Texture = new Vector2(l, 0.0f) }, new VertexData { Position = new Vector3(+l, -h, +l), Normal = Vector3.Up, Texture = new Vector2(l, l) }, }; uint[] indices = new uint[] { 0, 1, 2, 1, 3, 2, }; var material = MaterialContent.Default; material.AmbientColor = Color.White * 0.4f; material.DiffuseTexture = "resources/floor.png"; var content = ModelContent.GenerateTriangleList(vertices, indices, material); var desc = new ModelDescription() { UseAnisotropicFiltering = true, Content = new ContentDescription() { ModelContent = content, } }; this.AddComponent <Model>(desc, SceneObjectUsages.Ground); }
private void ProcessModelMeshParts(ModelContent model) { foreach (ModelMeshContent mesh in model.Meshes) { foreach (ModelMeshPartContent part in mesh.MeshParts) { part.Tag = new ModelMeshPartTag() { BoundingBox = new BoundingBox() }; /* * XamlSerializer.SerializationData.Add(new PropertyInstance(part.Tag, "Textures"), * part.Material.OpaqueData["AttachedTextures"] as Dictionary<TextureUsage, ContentReference<TextureContent>>); */ } } }
private void AnimationDataImport(ModelContent model, NodeContent input, ContentProcessorContext context) { for (int i = 0; i < model.Bones.Count; i++) { bones[model.Bones[i].Name] = i; } boneTransforms = new Matrix[model.Bones.Count]; AnimationDataImportRec(input); if (animationData.Clips.Count == 0) { Clip clip = new Clip(); animationData.Clips.Add(clip); string clipName = "Take 001"; clips[clipName] = clip; clip.Name = clipName; foreach (ModelBoneContent bone in model.Bones) { Clip.Bone clipBone = new Clip.Bone(); clipBone.Name = bone.Name; clip.Bones.Add(clipBone); } } foreach (Clip clip in animationData.Clips) { for (int b = 0; b < bones.Count; b++) { List <Clip.Keyframe> keyframes = clip.Bones[b].Keyframes; if (keyframes.Count == 0 || keyframes[0].Time > 0) { Clip.Keyframe keyframe = new Clip.Keyframe(); keyframe.Time = 0; keyframe.Transform = boneTransforms[b]; keyframes.Insert(0, keyframe); } } } }
/// <summary> /// The main Process method converts an intermediate format content pipeline NodeContent tree to an animation data format. /// </summary> public override ModelAnimationClip Process(NodeContent input, ContentProcessorContext context) { RigidModelProcessor rigidModelProcessor = new RigidModelProcessor(); ModelContent model = rigidModelProcessor.Process(input, context); if (string.IsNullOrEmpty(AnimationName)) // If no name was set then take the first animation { foreach (var animation in ((ModelAnimationData)model.Tag).ModelAnimationClips) { return(animation.Value); } throw new InvalidContentException("There is no rigid animation present in this model."); } if (((ModelAnimationData)model.Tag).ModelAnimationClips.ContainsKey(AnimationName)) { return(((ModelAnimationData)model.Tag).ModelAnimationClips[AnimationName]); } throw new InvalidContentException("There is no rigid animation present with this name."); } // Process
public override ModelContent Process(NodeContent input, ContentProcessorContext context) { //uncomment this to debug the content processor //System.Diagnostics.Debugger.Launch(); LevelTagData tag = new LevelTagData(); AddPointsTo(GetDataHolder(input, "light_poles"), tag.lightPoleLocations); AddPointsTo(GetDataHolder(input, "cars"), tag.cars); AddPointsTo(GetDataHolder(input, "mailbox1"), tag.mailbox1); AddPointsTo(GetDataHolder(input, "mailbox2"), tag.mailbox2); AddPointsTo(GetDataHolder(input, "beer"), tag.beer); ModelContent retModel = base.Process(input, context); retModel.Tag = tag; return(retModel); }
public override ModelContent Process(NodeContent input, ContentProcessorContext context) { CalculateTangentFrames(input, context); // The base processor will include the tagent frames in the resulting model ModelContent modelContent = base.Process(input, context); // Copy each mesh part's material name to it's tag. Chip rendering uses the // material name to determine which texture goes on which side. foreach (ModelMeshContent modelMesh in modelContent.Meshes) { foreach (ModelMeshPartContent modelMeshPart in modelMesh.MeshParts) { modelMeshPart.Tag = modelMeshPart.Material.Name; } } return(modelContent); }
public ActionResult Detail(int?Id) { ModelContent entity; int _languageId = 1; if (Id.HasValue && Id > 0) { Content model = _services.GetById(Id.Value); entity = new ModelContent { contentId = model.contentId, contentAlias = model.contentAlias, contentBody = model.contentBody, contentThumbnail = model.contentThumbnail, contentDescription = model.contentDescription, contentMetaKeywords = model.contentMetaKeywords, contentMetaTitle = model.contentMetaTitle, contentName = model.contentName, contentMetaDescription = model.contentMetaDescription, contentParentId = model.contentParentId, authorize = model.authorize, isNew = model.isNew ?? false, isFeature = model.isFeature ?? false, contentCreateTime = model.contentCreateTime.ToString("dd/MM/yyyy") }; ViewBag.Title = "Cập nhật tin tức"; } else { entity = new ModelContent { contentId = 0 }; ViewBag.Title = "Thêm mới tin tức"; } IEnumerable <DropdownModel> category = _services.Dropdownlist(0, null, "CHUYENMUCTINTUC", _languageId); ViewBag.contentParentId = category.Select(x => new SelectListItem { Text = x.Text, Value = x.Value.ToString() }); return(View(entity)); }
public override ModelContent Process(NodeContent input, ContentProcessorContext context) { MeshContent mesh = input as MeshContent; if (mesh != null) { MeshHelper.CalculateTangentFrames(mesh, VertexChannelNames.TextureCoordinate(0), VertexChannelNames.Tangent(0), VertexChannelNames.Binormal(0)); } // Use base ModelProcessor class to do the actual model processing ModelContent model = base.Process(input, context); return(model); }
/// <summary> /// Initialize lights /// </summary> /// <param name="drw">Drawing data</param> /// <param name="modelContent">Model content</param> private static void InitializeLights(ref DrawingData drw, ModelContent modelContent) { List <SceneLight> lights = new List <SceneLight>(); foreach (var key in modelContent.Lights.Keys) { var l = modelContent.Lights[key]; if (l.LightType == LightContentTypes.Point) { lights.Add(l.CreatePointLight()); } else if (l.LightType == LightContentTypes.Spot) { lights.Add(l.CreateSpotLight()); } } drw.Lights = lights.ToArray(); }
/// <summary> /// Initialize materials /// </summary> /// <param name="drw">Drawing data</param> /// <param name="modelContent">Model content</param> private static void InitializeMaterials(ref DrawingData drw, ModelContent modelContent) { foreach (string mat in modelContent.Materials?.Keys) { var effectInfo = modelContent.Materials[mat]; MeshMaterial meshMaterial = new MeshMaterial() { Material = new Material(effectInfo), EmissionTexture = drw.Textures[effectInfo.EmissionTexture], AmbientTexture = drw.Textures[effectInfo.AmbientTexture], DiffuseTexture = drw.Textures[effectInfo.DiffuseTexture], SpecularTexture = drw.Textures[effectInfo.SpecularTexture], ReflectiveTexture = drw.Textures[effectInfo.ReflectiveTexture], NormalMap = drw.Textures[effectInfo.NormalMapTexture], }; drw.Materials.Add(mat, meshMaterial); } }