//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { AddVDataArguments arguments = statement.Arguments as AddVDataArguments; OpsConsole.WriteLine(String.Format("Adding vertex element {0} of type {1}", arguments.FriendlyName, arguments.type)); foreach (OpsModel model in statement.GetContent(context)) { foreach (OpsMeshContainer meshContainer in model.GetMeshEnumerator()) { VertexElement[] OldVEs = meshContainer.MeshData.Mesh.Declaration.Clone() as VertexElement[]; int iExists; if (false == MeshDeclarationHelper.FindElement(OldVEs, arguments.usage, arguments.usageIdx, out iExists)) { int addedIdx; VertexElement[] VEs = MeshDeclarationHelper.AddElement(OldVEs, arguments.type, arguments.usage, arguments.usageIdx, out addedIdx); Mesh newMesh = meshContainer.MeshData.Mesh.Clone(meshContainer.MeshData.Mesh.Options.Value, VEs, meshContainer.MeshData.Mesh.Device); meshContainer.ReplaceMesh(newMesh); } else { OpsConsole.WriteLine(String.Format("Found existing vertex element {0}{1} on {2}", arguments.usage, arguments.usageIdx, meshContainer.FriendlyName(model))); } } } }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { AdjacencyArguments arguments = statement.Arguments as AdjacencyArguments; OpsConsole.WriteLine("Generating Adjacencies"); foreach (OpsModel model in statement.GetContent(context)) { foreach (OpsMeshContainer meshContainer in model.GetMeshEnumerator()) { int[] adj = null; if (arguments.Topological) { adj = meshContainer.MeshData.Mesh.ConvertPointRepsToAdjacency((int[])null); } else { adj = new int[meshContainer.MeshData.Mesh.NumberFaces * 3]; meshContainer.MeshData.Mesh.GenerateAdjacency( arguments.Epsilon, adj); } meshContainer.SetAdjacency(adj); } } }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { OptimizeArguments arguments = statement.Arguments as OptimizeArguments; OpsConsole.WriteLine("Optimizing models"); foreach (OpsModel model in statement.GetContent(context)) { foreach (OpsMeshContainer meshContainer in model.GetMeshEnumerator()) { int[] adjIn = null; int[] adjOut = null; int[] faceRemap = null; GraphicsStream vertexRemapStream = null; if (arguments.weldType != WeldType.None) { adjIn = meshContainer.GetAdjacency(); meshContainer.MeshData.Mesh.WeldVertices(arguments.epsilonFlags, arguments.epsilons, adjIn, out adjOut, out faceRemap, out vertexRemapStream); meshContainer.SetAdjacency(adjOut); meshContainer.RemapSkin(vertexRemapStream); } adjIn = meshContainer.GetAdjacency(); Mesh newMesh = meshContainer.MeshData.Mesh.Optimize(arguments.meshFlags, adjIn, out adjOut, out faceRemap, out vertexRemapStream); meshContainer.ReplaceMesh(newMesh); meshContainer.SetAdjacency(adjOut); meshContainer.RemapSkin(vertexRemapStream); } } }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { TexLoaderArgs texArgs = statement.Arguments as TexLoaderArgs; string[] paths = OpsHelpers.ResolvePathToMany(texArgs.Path as string); foreach (string path in paths) { OpsConsole.WriteLine("Loading texture from file: \"{0}\"", path); OpsTexture result = new OpsTexture(); ImageInformation Info = TextureLoader.ImageInformationFromFile(path); result.SRGB = texArgs.SRGB; if (Info.ResourceType == ResourceType.Textures) { result.Texture = TextureLoader.FromFile(context.Device, path); } else if (Info.ResourceType == ResourceType.VolumeTexture) { result.Texture = TextureLoader.FromVolumeFile(context.Device, path); } else if (Info.ResourceType == ResourceType.CubeTexture) { result.Texture = TextureLoader.FromCubeFile(context.Device, path); } result.Name = System.IO.Path.GetFileNameWithoutExtension(path); context.AddTexture(result); } }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { UnloadArguments args = statement.Arguments as UnloadArguments; if (args.Type == ContentType.GENERIC || args.Type == ContentType.MODELS) { ArrayList models = context.FindModels(args.Src); foreach (OpsModel model in models) { OpsConsole.WriteLine("Unloading model: '{0}'", model.Name); context.RemoveModel(model.Name); } } if (args.Type == ContentType.GENERIC || args.Type == ContentType.TEXTURES) { ArrayList textures = context.FindTextures(args.Src); foreach (OpsTexture texture in textures) { OpsConsole.WriteLine("Unloading texture: '{0}'", texture.Name); context.RemoveTexture(texture.Name); } } }
public void Run(OpsContext context, OpsStatement statement) { TexFormatArgs args = statement.Arguments as TexFormatArgs; ArrayList containers = statement.GetContent(context); OpsConsole.WriteLine("Changing texture formats to " + args.Format); foreach (OpsTexture container in containers) { if (container.Texture is Texture) { Texture oldTexture = container.Texture as Texture; SurfaceDescription sd = oldTexture.GetLevelDescription(0); container.Texture = OpsTextureHelper.CloneTexture(oldTexture, sd.Width, sd.Height, oldTexture.LevelCount, args.Format, Usage.None, Filter.Triangle | Filter.Dither | (container.SRGB?Filter.Srgb:0), Pool.Managed); } else if (container.Texture is VolumeTexture) { VolumeTexture oldTexture = container.Texture as VolumeTexture; VolumeDescription vd = oldTexture.GetLevelDescription(0); container.Texture = OpsTextureHelper.CloneVolume(oldTexture, vd.Width, vd.Height, vd.Depth, oldTexture.LevelCount, args.Format, Usage.None, Filter.Triangle | Filter.Dither | (container.SRGB?Filter.Srgb:0), Pool.Managed); } else if (container.Texture is CubeTexture) { CubeTexture oldTexture = container.Texture as CubeTexture; SurfaceDescription sd = oldTexture.GetLevelDescription(0); container.Texture = OpsTextureHelper.CloneCube(oldTexture, sd.Width, oldTexture.LevelCount, args.Format, Usage.None, Filter.Triangle | Filter.Dither | (container.SRGB?Filter.Srgb:0), Pool.Managed); } } }
public void Run(OpsContext context, OpsStatement statement) { OpsConsole.WriteLine("Texture information"); OpsConsole.WriteLine(format, "Names", "Type", "Width", "Height", "Depth", "Mips", "Format"); foreach (OpsTexture container in statement.GetContent(context)) { string name = container.Name; string type = container.Texture.GetType().Name; int width = 0; int height = 0; int depth = 0; int mips = 0; string pixelFormat = ""; if (container.Texture is Texture) { Texture texture = container.Texture as Texture; SurfaceDescription sd = texture.GetLevelDescription(0); width = sd.Width; height = sd.Height; mips = texture.LevelCount; pixelFormat = sd.Format.ToString(); } else if (container.Texture is VolumeTexture) { VolumeTexture texture = container.Texture as VolumeTexture; VolumeDescription vd = texture.GetLevelDescription(0); width = vd.Width; height = vd.Height; depth = vd.Depth; mips = texture.LevelCount; pixelFormat = vd.Format.ToString(); } else if (container.Texture is CubeTexture) { CubeTexture texture = container.Texture as CubeTexture; SurfaceDescription sd = texture.GetLevelDescription(0); width = sd.Width; height = sd.Height; mips = texture.LevelCount; pixelFormat = sd.Format.ToString(); } OpsConsole.WriteLine(format, name, type, width, height, depth, mips, pixelFormat); } }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { OpsConsole.WriteLine("Generating normals"); foreach (OpsModel model in statement.GetContent(context)) { foreach (OpsMeshContainer meshContainer in model.GetMeshEnumerator()) { meshContainer.MeshData.Mesh.ComputeNormals(meshContainer.GetAdjacencyStream()); } } }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { OpsUVAtlasArguments options = statement.Arguments as OpsUVAtlasArguments; OpsConsole.WriteLine("UVAtlasing models. This might take a while."); foreach (OpsModel model in statement.GetContent(context)) { foreach (OpsMeshContainer meshContainer in model.GetMeshEnumerator()) { OpsConsole.WriteLine("\t\tBeginning " + meshContainer.FriendlyName(model)); VertexElement[] VEs = meshContainer.MeshData.Mesh.Declaration; int destinationIdx; if (false == MeshDeclarationHelper.FindElement(VEs, DeclarationUsage.TextureCoordinate, options.TexIdx, out destinationIdx)) { throw new OpsException("Cannot generate UVAtlas without texture coordinates (use command AddVData)"); } UVAtlasOutput uvout; try { uvout = UVAtlas.Create( meshContainer.MeshData.Mesh, options.MaxCharts, options.Stretch, options.Width, options.Height, options.Gutter, options.TexIdx, meshContainer.GetAdjacencyStream(), null, null, 0.0f); } catch (Microsoft.DirectX.Direct3D.InvalidMeshException e) { throw new OpsException("UVAtlas considers this mesh invalid. This is most likely because the mesh is non-manifold. Using the clean and optimize commands first to remove some non-manifold properties MAY fix the problem. Also consider less restrictive argument values.", e); } catch (Exception e) { throw new OpsException("UVAtlas was unable to complete. Try using more flexible argument values, cleaning, and/or optimizing models first.", e); } meshContainer.ReplaceMesh(uvout.Mesh); meshContainer.RemapSkin(uvout.VertexRemapArray); OpsConsole.WriteLine("\ttCompleted"); } } }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { string[] paths = OpsHelpers.ResolvePathToMany(statement.Arguments as string); foreach (string path in paths) { OpsConsole.WriteLine("Loading model from file: \"{0}\"", path); OpsModel model = OpsModel.FromFile(context.Device, path); context.AddModel(model); } }
public void Run(OpsContext context, OpsStatement statement) { MipArgs args = statement.Arguments as MipArgs; ArrayList containers = statement.GetContent(context); OpsConsole.WriteLine("Generating Mipmaps"); foreach (OpsTexture container in containers) { TextureLoader.FilterTexture(container.Texture, args.Start, args.Filter | (container.SRGB?Filter.Srgb:0)); } }
public void Run(OpsContext context, OpsStatement statement) { Slice2dArgs args = statement.Arguments as Slice2dArgs; ArrayList containers = statement.GetContent(context); if (containers.Count != 1) { throw new OpsException("Src argument does not resolve to 1 texture. Textures found: " + containers.Count); } OpsTexture container = containers[0] as OpsTexture; OpsConsole.WriteLine("Slicing from texture:{0} and saving as {1}", container.Name, args.Dst); OpsTexture result = new OpsTexture(); result.Name = args.Dst; result.SRGB = container.SRGB; Texture newTexture = null; if (container.Texture is Texture) { Texture srcTexture = container.Texture as Texture; SurfaceDescription sd = srcTexture.GetLevelDescription(args.Mips); newTexture = new Texture(srcTexture.Device, sd.Width, sd.Height, 1, Usage.None, sd.Format, Pool.Managed); SurfaceLoader.FromSurface(newTexture.GetSurfaceLevel(0), srcTexture.GetSurfaceLevel(0), Filter.Dither | Filter.Triangle | (container.SRGB?Filter.Srgb:0), 0); } else if (container.Texture is VolumeTexture) { VolumeTexture srcTexture = container.Texture as VolumeTexture; VolumeDescription vd = srcTexture.GetLevelDescription(args.Mips); newTexture = new Texture(srcTexture.Device, vd.Width, vd.Height, 1, Usage.None, vd.Format, Pool.Managed); OpsTextureHelper.LoadSurfaceFromVolumeSlice(srcTexture, args.Mips, args.Volume, Filter.Dither | Filter.Triangle | (container.SRGB?Filter.Srgb:0), newTexture.GetSurfaceLevel(0)); } else if (container.Texture is CubeTexture) { CubeTexture srcTexture = container.Texture as CubeTexture; SurfaceDescription sd = srcTexture.GetLevelDescription(args.Mips); newTexture = new Texture(srcTexture.Device, sd.Width, sd.Height, 1, Usage.None, sd.Format, Pool.Managed); SurfaceLoader.FromSurface(newTexture.GetSurfaceLevel(0), srcTexture.GetCubeMapSurface(args.Face, 0), Filter.Dither | Filter.Triangle | (container.SRGB?Filter.Srgb:0), 0); } result.Texture = newTexture; context.AddTexture(result); }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { FlattenArguments arguments = statement.Arguments as FlattenArguments; ArrayList models = statement.GetContent(context); OpsConsole.WriteLine("Flattening models into '{0}'", arguments.NewModel); Mesh[] meshes; Matrix[] localToWorlds; int[][] adjacencies; ExtendedMaterial[] materials; EffectInstance[] effectInstances; GetLists(models, out meshes, out localToWorlds, out adjacencies, out materials, out effectInstances); Mesh newMesh = PrtEngine.ConcatenateMeshes( meshes, MeshFlags.SystemMemory | MeshFlags.Use32Bit, localToWorlds, null, null, context.Device); int[] newAdj = ConcatenateAdjacency(newMesh, meshes, adjacencies); OpsMeshContainer newMC = new OpsMeshContainer(); newMC.Name = arguments.NewModel; newMC.ReplaceMesh(newMesh); newMC.SetMaterials(materials); newMC.SetEffectInstances(effectInstances); newMC.SetAdjacency(newAdj); OpsFrame newFrame = new OpsFrame(); newFrame.Name = arguments.NewModel; newFrame.MeshContainer = newMC; OpsModel newModel = new OpsModel(); newModel.Name = arguments.NewModel; newModel.HierarchyRoot = newFrame; context.AddModel(newModel); }
public void Run(OpsContext context, OpsStatement statement) { Splice2dArgs args = statement.Arguments as Splice2dArgs; ArrayList srcList = statement.GetContent(context); if (srcList.Count != 1) { throw new OpsException("Could not find the source texture. 1 is require but found " + srcList.Count); } OpsTexture srcContainer = ((OpsTexture)srcList[0]); if (!(srcContainer.Texture is Texture)) { throw new OpsException("Source texture is not 2D"); } Texture srcTexture = srcContainer.Texture as Texture; OpsConsole.WriteLine("Splicing texture:{0} into one or more textures", srcContainer.Name); ArrayList dstContainers = context.FindTextures(args.Dst); foreach (OpsTexture dstContainer in dstContainers) { if (dstContainer.Texture is Texture) { Texture dstTexture = dstContainer.Texture as Texture; SurfaceLoader.FromSurface(dstTexture.GetSurfaceLevel(args.Mips), srcTexture.GetSurfaceLevel(0), Filter.Dither | Filter.Triangle | (srcContainer.SRGB?Filter.SrgbIn:0) | (dstContainer.SRGB?Filter.SrgbOut:0), 0); } else if (dstContainer.Texture is VolumeTexture) { VolumeTexture dstTexture = dstContainer.Texture as VolumeTexture; OpsTextureHelper.LoadVolumeSliceFromSurface(dstTexture, args.Mips, args.Volume, Filter.Dither | Filter.Triangle | (srcContainer.SRGB?Filter.SrgbIn:0) | (dstContainer.SRGB?Filter.SrgbOut:0), srcTexture.GetSurfaceLevel(0)); } else if (dstContainer.Texture is CubeTexture) { CubeTexture dstTexture = dstContainer.Texture as CubeTexture; SurfaceLoader.FromSurface(dstTexture.GetCubeMapSurface(args.Face, args.Mips), srcTexture.GetSurfaceLevel(0), Filter.Dither | Filter.Triangle | (srcContainer.SRGB?Filter.SrgbIn:0) | (dstContainer.SRGB?Filter.SrgbOut:0), 0); } } }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { DelVDataArguments arguments = statement.Arguments as DelVDataArguments; OpsConsole.WriteLine(String.Format("Deleting vertex element {0}", arguments.FriendlyName)); foreach (OpsModel model in statement.GetContent(context)) { foreach (OpsMeshContainer meshContainer in model.GetMeshEnumerator()) { VertexElement[] OldVEs = meshContainer.MeshData.Mesh.Declaration.Clone() as VertexElement[]; int srcUsageIdx = arguments.usageIdx; if (arguments.hasSrcUsageIdx == false) { for (int i = 0; i < OldVEs.Length; i++) { if (OldVEs[i].DeclarationUsage == arguments.usage) { srcUsageIdx = OldVEs[i].UsageIndex; break; } } } if (srcUsageIdx < 0) { continue; } int iRemove; if (MeshDeclarationHelper.FindElement(OldVEs, arguments.usage, srcUsageIdx, out iRemove)) { VertexElement[] VEs = MeshDeclarationHelper.RemoveElement(OldVEs, iRemove); Mesh newMesh = meshContainer.MeshData.Mesh.Clone(meshContainer.MeshData.Mesh.Options.Value, VEs, meshContainer.MeshData.Mesh.Device); meshContainer.ReplaceMesh(newMesh); } else { OpsConsole.WriteLine(String.Format("Could not find vertex element {0}{1} on {2}", arguments.usage, arguments.usageIdx, meshContainer.FriendlyName(model))); } } } }
public void Run(OpsContext context, OpsStatement statement) { NewTex3dArgs args = statement.Arguments as NewTex3dArgs; OpsConsole.WriteLine("Creating new volume texture named " + args.Name); OpsTexture result = new OpsTexture(); result.Name = args.Name; VolumeTexture newTexture = new VolumeTexture(context.Device, args.Width, args.Height, args.Depth, args.Mips, Usage.None, args.Format, Pool.Managed); result.Texture = newTexture; CopyToVolume(context, newTexture, args.Src, Filter.Triangle | Filter.Dither); context.AddTexture(result); }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { TexSaverArgs texArgs = statement.Arguments as TexSaverArgs; ArrayList containers = statement.GetContent(context); if (containers.Count != 1) { throw new OpsException("'src' argument resolves to " + containers.Count + " textures where it must be 1 texture"); } OpsTexture container = containers[0] as OpsTexture; OpsConsole.WriteLine("Saving texture: {0} to path: {1}", container.Name, texArgs.Path); TextureLoader.Save(texArgs.Path, texArgs.Format, container.Texture); }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { OpsConsole.WriteLine("Validating models"); foreach (OpsModel model in statement.GetContent(context)) { foreach (OpsMeshContainer meshContainer in model.GetMeshEnumerator()) { string errorsAndWarnings; meshContainer.MeshData.Mesh.Validate(meshContainer.GetAdjacencyStream(), out errorsAndWarnings); if (errorsAndWarnings.Length != 0) { OpsConsole.WriteLine("Invalid " + meshContainer.FriendlyName(model)); OpsConsole.WriteLine(errorsAndWarnings); } } } }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { OpsConsole.WriteLine("Mesh information"); foreach (OpsModel model in statement.GetContent(context)) { OpsConsole.WriteLine("MODEL: '{0}'", model.Name); OpsConsole.WriteLine(format, "Names", "Faces", "Vertices", "Attributes", "Boundings"); foreach (OpsMeshContainer meshContainer in model.GetMeshEnumerator()) { float radius = 0; VertexElement[] VEs = meshContainer.MeshData.Mesh.Declaration; int posIdx; if (MeshDeclarationHelper.FindElement(VEs, DeclarationUsage.Position, 0, out posIdx)) { using (VertexBuffer vb = meshContainer.MeshData.Mesh.VertexBuffer) { GraphicsStream vertexData = vb.Lock(VEs[posIdx].Offset, vb.Description.Size - VEs[posIdx].Offset, LockFlags.None); Vector3 center; radius = Geometry.ComputeBoundingSphere(vertexData, meshContainer.MeshData.Mesh.NumberVertices, meshContainer.MeshData.Mesh.NumberBytesPerVertex, out center); vb.Unlock(); } } OpsConsole.WriteLine(format, meshContainer.Name, meshContainer.MeshData.Mesh.NumberFaces, meshContainer.MeshData.Mesh.NumberVertices, meshContainer.MeshData.Mesh.NumberAttributes, radius); } } }
public void Run(OpsContext context, OpsStatement statement) { NewTexCubeArgs args = statement.Arguments as NewTexCubeArgs; OpsConsole.WriteLine("Creating new cube texture named" + args.Name); OpsTexture result = new OpsTexture(); result.Name = args.Name; CubeTexture newTexture = new CubeTexture(context.Device, args.Size, args.Mips, Usage.None, args.Format, Pool.Managed); result.Texture = newTexture; CopyToCubeSide(context, newTexture, args.SrcXP, CubeMapFace.PositiveX, Filter.Triangle | Filter.Dither); CopyToCubeSide(context, newTexture, args.SrcYP, CubeMapFace.PositiveY, Filter.Triangle | Filter.Dither); CopyToCubeSide(context, newTexture, args.SrcZP, CubeMapFace.PositiveZ, Filter.Triangle | Filter.Dither); CopyToCubeSide(context, newTexture, args.SrcXM, CubeMapFace.NegativeX, Filter.Triangle | Filter.Dither); CopyToCubeSide(context, newTexture, args.SrcYM, CubeMapFace.NegativeY, Filter.Triangle | Filter.Dither); CopyToCubeSide(context, newTexture, args.SrcZM, CubeMapFace.NegativeZ, Filter.Triangle | Filter.Dither); context.AddTexture(result); }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { SavexArguments arguments = statement.Arguments as SavexArguments; ArrayList models = statement.GetContent(context); if (models.Count != 1) { string errorStr = string.Format("Save requires only one model but found {0}. Try changing/using the Src argument.", models.Count); throw new OpsException(errorStr); } OpsModel model = models[0] as OpsModel; OpsConsole.WriteLine("Saving model: {0} to path: {1}", model.Name, arguments.Filename); if (model.HierarchyRoot == null) { throw new OpsException("There is nothing currently in the application's context. Must use a Load command first."); } Mesh.SaveHierarchyToFile(arguments.Filename, arguments.saveType, model.HierarchyRoot, model.AnimationMixer, null); }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { StripifyArguments arguments = statement.Arguments as StripifyArguments; OpsConsole.WriteLine("Stripifying models"); foreach (OpsModel model in statement.GetContent(context)) { foreach (OpsMeshContainer meshContainer in model.GetMeshEnumerator()) { int[] adjIn = null; int[] adjOut = null; int[] faceRemap = null; GraphicsStream vertexRemapStream = null; adjIn = meshContainer.GetAdjacency(); Mesh oldMesh = meshContainer.MeshData.Mesh; Mesh newMesh = oldMesh.Optimize(arguments.meshFlags, adjIn, out adjOut, out faceRemap, out vertexRemapStream); meshContainer.ReplaceMesh(newMesh); meshContainer.SetAdjacency(adjOut); meshContainer.RemapSkin(vertexRemapStream); } } }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { TangentArguments options = statement.Arguments as TangentArguments; OpsConsole.WriteLine("Generating tangent frames"); foreach (OpsModel model in statement.GetContent(context)) { foreach (OpsMeshContainer meshContainer in model.GetMeshEnumerator()) { VertexElement[] VEs = meshContainer.MeshData.Mesh.Declaration; int texIdx; if (false == MeshDeclarationHelper.FindElement(VEs, DeclarationUsage.TextureCoordinate, 0, out texIdx)) { throw new OpsException("Cannot generate tangents without texture coordinates (use command uvatlas)"); } int normIdx; if (false == MeshDeclarationHelper.FindElement(VEs, DeclarationUsage.Normal, 0, out normIdx)) { throw new OpsException("Cannot generate tangents without normals (use command GenNormals)"); } int tanIdx; if (false == MeshDeclarationHelper.FindElement(VEs, DeclarationUsage.Tangent, 0, out tanIdx)) { throw new OpsException("Cannot generate tangents without a place to store Tangent0 (use command AddVData)"); } int binormIdx; if (false == MeshDeclarationHelper.FindElement(VEs, DeclarationUsage.BiNormal, 0, out binormIdx)) { throw new OpsException("Cannot generate tangents without a place to store BiNormal0 (use command AddVData)"); } bool success = false; try { GraphicsStream vertexRemapStream = null; Mesh newMesh = Geometry.ComputeTangentFrame( meshContainer.MeshData.Mesh, (int)DeclarationUsage.TextureCoordinate, options.TexIdx, (int)DeclarationUsage.Tangent, 0, (int)DeclarationUsage.BiNormal, 0, (int)DeclarationUsage.Normal, 0, options.Options, meshContainer.GetAdjacencyStream(), options.ThreshPE, options.ThreshSP, options.ThreshNE, out vertexRemapStream); if (newMesh != null) { meshContainer.ReplaceMesh(newMesh); meshContainer.RemapSkin(vertexRemapStream); success = true; } else { success = false; OpsConsole.WriteLine("Failed in 1st attempt to generate tangents on " + meshContainer.FriendlyName(model)); } } catch (Exception) { OpsConsole.WriteLine("Failed in 1st attempt to generate tangents on " + meshContainer.FriendlyName(model)); //eating exception } if (!success) { try { meshContainer.MeshData.Mesh.ComputeTangent( options.TexIdx, 0, 0, 0, meshContainer.GetAdjacencyStream()); } catch (Exception) { OpsConsole.WriteLine("Failed in final attempt to generate tangents on " + meshContainer.FriendlyName(model)); throw; } } } } }
public void Run(OpsContext context, OpsStatement statement) { TexResizeArgs args = statement.Arguments as TexResizeArgs; ArrayList containers = statement.GetContent(context); OpsConsole.WriteLine("Resizing textures to width:{0} height:{1} depth:{2}", args.Width, args.Height, args.Depth); foreach (OpsTexture container in containers) { if (container.Texture is Texture) { Texture oldTexture = container.Texture as Texture; SurfaceDescription sd = oldTexture.GetLevelDescription(0); if (args.Width == -1) { args.Width = sd.Width; } if (args.Height == -1) { args.Height = sd.Height; } int mips = OpsTextureHelper.NumMips(args.Width, args.Height, 1); container.Texture = OpsTextureHelper.CloneTexture(oldTexture, args.Width, args.Height, mips, sd.Format, Usage.None, args.Filter | (container.SRGB ? Filter.Srgb : 0), Pool.Managed); } else if (container.Texture is VolumeTexture) { VolumeTexture oldTexture = container.Texture as VolumeTexture; VolumeDescription vd = oldTexture.GetLevelDescription(0); if (args.Width == -1) { args.Width = vd.Width; } if (args.Height == -1) { args.Height = vd.Height; } if (args.Depth == -1) { args.Depth = vd.Depth; } int mips = OpsTextureHelper.NumMips(args.Width, args.Height, args.Depth); container.Texture = OpsTextureHelper.CloneVolume(oldTexture, args.Width, args.Height, args.Depth, mips, vd.Format, Usage.None, args.Filter | (container.SRGB ? Filter.Srgb : 0), Pool.Managed); } else if (container.Texture is CubeTexture) { CubeTexture oldTexture = container.Texture as CubeTexture; SurfaceDescription sd = oldTexture.GetLevelDescription(0); if (args.Width == -1) { args.Width = sd.Width; } int mips = OpsTextureHelper.NumMips(args.Width, args.Width, 1); container.Texture = OpsTextureHelper.CloneCube(oldTexture, args.Width, mips, sd.Format, Usage.None, args.Filter | (container.SRGB ? Filter.Srgb : 0), Pool.Managed); } } }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { OpsConsole.WriteLine("Cleaning models"); foreach (OpsModel model in statement.GetContent(context)) { foreach (OpsMeshContainer meshContainer in model.GetMeshEnumerator()) { string errorsAndWarnings; meshContainer.MeshData.Mesh.Validate(meshContainer.GetAdjacencyStream(), out errorsAndWarnings); if (errorsAndWarnings == null || errorsAndWarnings.Length == 0) { continue; } else { OpsConsole.WriteLine("Cleaning '{0}'", meshContainer.FriendlyName(model)); OpsConsole.WriteLine(errorsAndWarnings); } VertexElement[] OldVEs = null; int offsetOfIndex = -1; Mesh dirtyMesh = meshContainer.MeshData.Mesh; if (meshContainer.SkinInformation != null) { int psizeUsageIdx = -1; int remapIdx = -1; OldVEs = meshContainer.MeshData.Mesh.Declaration.Clone() as VertexElement[]; if (!MeshDeclarationHelper.FindValidUsageIndex(OldVEs, DeclarationUsage.PointSize, out psizeUsageIdx)) { throw new OpsException("Could not add remapping-indexing vertex element to declaration"); } VertexElement[] VEs = MeshDeclarationHelper.AddElement(OldVEs, DeclarationType.Float1, DeclarationUsage.PointSize, psizeUsageIdx, out remapIdx); dirtyMesh = meshContainer.MeshData.Mesh.Clone(meshContainer.MeshData.Mesh.Options.Value, VEs, meshContainer.MeshData.Mesh.Device); offsetOfIndex = VEs[remapIdx].Offset; VertexBuffer vb = dirtyMesh.VertexBuffer; GraphicsStream gs = vb.Lock(0, 0, LockFlags.None); for (int iVertex = 0; iVertex < dirtyMesh.NumberVertices; iVertex++) { gs.Seek(dirtyMesh.NumberBytesPerVertex * iVertex + offsetOfIndex, SeekOrigin.Begin); gs.Write(iVertex); } vb.Unlock(); gs = null; vb = null; } int[] adjOut; Mesh cleanedMesh = Mesh.Clean(CleanType.BackFacing | CleanType.BowTies, dirtyMesh, meshContainer.GetAdjacency(), out adjOut, out errorsAndWarnings); if (errorsAndWarnings != null && errorsAndWarnings.Length != 0) { OpsConsole.WriteLine("Remaining Errors and Warnings:"); OpsConsole.WriteLine(errorsAndWarnings); } if (meshContainer.SkinInformation != null) { int[] vertexRemap = new int[cleanedMesh.NumberVertices]; VertexBuffer vb = cleanedMesh.VertexBuffer; GraphicsStream gs = vb.Lock(0, 0, LockFlags.None); for (int iVertex = 0; iVertex < cleanedMesh.NumberVertices; iVertex++) { gs.Seek(cleanedMesh.NumberBytesPerVertex * iVertex + offsetOfIndex, SeekOrigin.Begin); vertexRemap[iVertex] = (int)gs.Read(typeof(int)); } vb.Unlock(); meshContainer.RemapSkin(vertexRemap); cleanedMesh = cleanedMesh.Clone(cleanedMesh.Options.Value, OldVEs, cleanedMesh.Device); } meshContainer.SetAdjacency(adjOut); meshContainer.ReplaceMesh(cleanedMesh); } } }
public void Run(OpsContext context, OpsStatement statement) { ShadeArgs args = statement.Arguments as ShadeArgs; ConstantTable constantTable = SetupDevice(context, args); EffectHandle hTarget = constantTable.GetConstant(null, "Target"); ArrayList containers = statement.GetContent(context); OpsConsole.WriteLine("Shading textures with \"{0}\"", args.File); foreach (OpsTexture container in containers) { if (hTarget != null) { context.Device.SetTexture( constantTable.GetSamplerIndex(hTarget), container.Texture); } if (container.Texture is Texture) { Texture oldTexture = container.Texture as Texture; Texture newTexture = OpsTextureHelper.CloneTexture(oldTexture, Usage.None, Pool.Managed); for (int mip = 0; mip < oldTexture.LevelCount; mip++) { SurfaceDescription sd = oldTexture.GetLevelDescription(mip); CheckFormatValid(sd.Format); Surface rt = context.Device.CreateRenderTarget(sd.Width, sd.Height, sd.Format, MultiSampleType.None, 0, true); context.Device.SetRenderTarget(0, rt); ShadeVertex[] vb = new ShadeVertex[] { ShadeVertex.ForTexture(-1.0f, -1.0f, sd.Width, sd.Height), ShadeVertex.ForTexture(1.0f, -1.0f, sd.Width, sd.Height), ShadeVertex.ForTexture(-1.0f, 1.0f, sd.Width, sd.Height), ShadeVertex.ForTexture(1.0f, 1.0f, sd.Width, sd.Height), }; context.Device.BeginScene(); context.Device.DrawUserPrimitives(PrimitiveType.TriangleStrip, 2, vb); context.Device.EndScene(); context.Device.SetRenderTarget(0, context.Device.GetBackBuffer(0, 0, BackBufferType.Mono)); SurfaceLoader.FromSurface(newTexture.GetSurfaceLevel(mip), rt, Filter.None | (container.SRGB?Filter.SrgbOut:0), 0); } oldTexture.Dispose(); container.Texture = newTexture; } else if (container.Texture is VolumeTexture) { VolumeTexture oldTexture = container.Texture as VolumeTexture; VolumeTexture newTexture = OpsTextureHelper.CloneVolume(oldTexture, Usage.None, Pool.Managed); for (int mip = 0; mip < oldTexture.LevelCount; mip++) { VolumeDescription vd = oldTexture.GetLevelDescription(mip); CheckFormatValid(vd.Format); Surface sliceRT = context.Device.CreateRenderTarget(vd.Width, vd.Height, vd.Format, MultiSampleType.None, 0, true); for (int slice = 0; slice < vd.Depth; slice++) { context.Device.SetRenderTarget(0, sliceRT); ShadeVertex[] vb = new ShadeVertex[] { ShadeVertex.ForVolume(-1.0f, -1.0f, slice, vd.Width, vd.Height, vd.Depth), ShadeVertex.ForVolume(1.0f, -1.0f, slice, vd.Width, vd.Height, vd.Depth), ShadeVertex.ForVolume(-1.0f, 1.0f, slice, vd.Width, vd.Height, vd.Depth), ShadeVertex.ForVolume(1.0f, 1.0f, slice, vd.Width, vd.Height, vd.Depth), }; context.Device.BeginScene(); context.Device.DrawUserPrimitives(PrimitiveType.TriangleStrip, 2, vb); context.Device.EndScene(); context.Device.SetRenderTarget(0, context.Device.GetBackBuffer(0, 0, BackBufferType.Mono)); OpsTextureHelper.LoadVolumeSliceFromSurface(newTexture, mip, slice, Filter.None | (container.SRGB?Filter.SrgbOut:0), sliceRT); } sliceRT.Dispose(); } oldTexture.Dispose(); container.Texture = newTexture; } else if (container.Texture is CubeTexture) { CubeTexture oldTexture = container.Texture as CubeTexture; CubeTexture newTexture = OpsTextureHelper.CloneCube(oldTexture, Usage.None, Pool.Managed); for (int mip = 0; mip < oldTexture.LevelCount; mip++) { SurfaceDescription sd = oldTexture.GetLevelDescription(mip); CheckFormatValid(sd.Format); Surface rt = context.Device.CreateRenderTarget(sd.Width, sd.Height, sd.Format, MultiSampleType.None, 0, true); RenderCubeMapFace(context, newTexture, rt, CubeMapFace.PositiveX, mip, sd.Width, container.SRGB); RenderCubeMapFace(context, newTexture, rt, CubeMapFace.PositiveY, mip, sd.Width, container.SRGB); RenderCubeMapFace(context, newTexture, rt, CubeMapFace.PositiveZ, mip, sd.Width, container.SRGB); RenderCubeMapFace(context, newTexture, rt, CubeMapFace.NegativeX, mip, sd.Width, container.SRGB); RenderCubeMapFace(context, newTexture, rt, CubeMapFace.NegativeY, mip, sd.Width, container.SRGB); RenderCubeMapFace(context, newTexture, rt, CubeMapFace.NegativeZ, mip, sd.Width, container.SRGB); } oldTexture.Dispose(); container.Texture = newTexture; } } }
private ConstantTable SetupDevice(OpsContext context, ShadeArgs args) { string errStr = null; ConstantTable constantTable; GraphicsStream pshader; GraphicsStream vshader; try { ConstantTable dummyTable; errStr = null; vshader = ShaderLoader.CompileShader(ShadeVertex.VertexShader, "VertexShader", null, null, "vs_3_0", ShaderFlags.None, out errStr, out dummyTable); } finally { if (errStr != null && errStr.Length > 0) { OpsConsole.WriteLine("Vertex Shader Compiler messages: " + errStr); OpsConsole.WriteLine("If this message is regarding your entry point, it may be something other than the default 'main'. Please use the argument 'Shader' to specify it."); } } try { Macro dxopsMacro = new Macro(); dxopsMacro.Name = "__DXOPS"; dxopsMacro.Definition = "1"; errStr = null; pshader = ShaderLoader.CompileShaderFromFile(args.File, args.Shader, new Macro[] { dxopsMacro }, null, "ps_3_0", ShaderFlags.None, out errStr, out constantTable); } finally { if (errStr != null && errStr.Length > 0) { OpsConsole.WriteLine("Pixel Shader Compiler messages: " + errStr); OpsConsole.WriteLine("If this message is regarding your entry point, it may be something other than the default 'main'. Please use the argument 'Shader' to specify it."); } } context.Device.SetRenderState(RenderStates.CullMode, (int)Cull.None); context.Device.SetRenderState(RenderStates.FillMode, (int)FillMode.Solid); context.Device.SetRenderState(RenderStates.AlphaTestEnable, false); context.Device.SetRenderState(RenderStates.AlphaBlendEnable, false); context.Device.SetRenderState(RenderStates.StencilEnable, false); context.Device.SetRenderState(RenderStates.ZEnable, false); context.Device.SetRenderState(RenderStates.ZBufferWriteEnable, false); context.Device.DepthStencilSurface = null; VertexDeclaration decl = new VertexDeclaration(context.Device, ShadeVertex.VertexDeclaration); context.Device.VertexDeclaration = decl; VertexShader vs = new VertexShader(context.Device, vshader); context.Device.VertexShader = vs; PixelShader ps = new PixelShader(context.Device, pshader); context.Device.PixelShader = ps; constantTable.SetDefaults(context.Device); foreach (OpsParsedArgument constant in args.Constants) { EffectHandle h = constantTable.GetConstant(null, constant.Name); if (h == null) { OpsConsole.WriteLine("WARNING: Parameter '{0}' was not found in shader.", constant.Name); continue; } ConstantDescription[] cds = constantTable.GetConstantDescription(h, 1); ConstantDescription cd = cds[0]; switch (cd.Class) { case ParameterClass.Object: { //texture switch (cd.ParameterType) { case ParameterType.Texture: case ParameterType.Texture1D: case ParameterType.Texture2D: case ParameterType.Texture3D: case ParameterType.TextureCube: { OpsTexture container = context.GetTexture(constant.Value); int sampler = constantTable.GetSamplerIndex(h); context.Device.SetTexture(sampler, container.Texture); } break; } break; } case ParameterClass.Scalar: case ParameterClass.Vector: case ParameterClass.MatrixColumns: case ParameterClass.MatrixRows: { ArrayList floatList = new ArrayList(); string[] floatStrings = constant.Value.Split(new char[] { ' ', ',' }); foreach (string floatStr in floatStrings) { if (floatStr.Length > 0) { floatList.Add(float.Parse(floatStr)); } } float[] floats = (float[])floatList.ToArray(typeof(float)); constantTable.SetValue(context.Device, h, floats); } break; } } return(constantTable); }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { CloneVDataArguments arguments = statement.Arguments as CloneVDataArguments; OpsConsole.WriteLine(String.Format("Cloning vertex element {0} as {1}", arguments.FriendlySrcName, arguments.FriendlyDstName)); foreach (OpsModel model in statement.GetContent(context)) { foreach (OpsMeshContainer meshContainer in model.GetMeshEnumerator()) { int srcIdx; int dstIdx; VertexElement[] OldVEs = meshContainer.MeshData.Mesh.Declaration.Clone() as VertexElement[]; int srcUsageIdx = arguments.srcUsageIdx; if (arguments.hasSrcUsageIdx == false) { for (int i = 0; i < OldVEs.Length; i++) { if (OldVEs[i].DeclarationUsage == arguments.srcUsage) { srcUsageIdx = OldVEs[i].UsageIndex; break; } } } if (srcUsageIdx < 0) { continue; } if (!MeshDeclarationHelper.FindElement(OldVEs, arguments.srcUsage, srcUsageIdx, out srcIdx)) { throw new OpsException("Could not find source vertex element"); } int dstUsageIdxPerMesh = arguments.dstUsageIdx; if (!arguments.hasDstUsageIdx) { if (MeshDeclarationHelper.FindValidUsageIndex(OldVEs, arguments.dstUsage, out dstUsageIdxPerMesh, out dstIdx)) { throw new OpsException("Could not find open usage index for destination vertex element"); } } int copyIdx; VertexElement[] VEs = MeshDeclarationHelper.AddElement(OldVEs, OldVEs[srcIdx].DeclarationType, arguments.dstUsage, dstUsageIdxPerMesh, out copyIdx); if (!MeshDeclarationHelper.FindElement(VEs, arguments.srcUsage, srcUsageIdx, out srcIdx)) { throw new OpsException("Could not find source vertex element"); } if (!MeshDeclarationHelper.FindElement(VEs, arguments.dstUsage, dstUsageIdxPerMesh, out dstIdx)) { throw new OpsException("Could not find destination vertex element"); } Mesh newMesh = meshContainer.MeshData.Mesh.Clone(meshContainer.MeshData.Mesh.Options.Value, VEs, meshContainer.MeshData.Mesh.Device); int sizeInBytes = MeshDeclarationHelper.GetTypeSize(VEs[srcIdx].DeclarationType); int srcOffset = VEs[srcIdx].Offset; int dstOffset = VEs[dstIdx].Offset; byte[] copyBuffer = new byte[sizeInBytes]; VertexBuffer vb = newMesh.VertexBuffer; GraphicsStream gs = vb.Lock(0, 0, LockFlags.None); for (int iVertex = 0; iVertex < newMesh.NumberVertices; iVertex++) { gs.Seek(newMesh.NumberBytesPerVertex * iVertex + srcOffset, SeekOrigin.Begin); gs.Read(copyBuffer, 0, sizeInBytes); gs.Seek(newMesh.NumberBytesPerVertex * iVertex + dstOffset, SeekOrigin.Begin); gs.Write(copyBuffer, 0, sizeInBytes); } vb.Unlock(); gs = null; vb = null; meshContainer.ReplaceMesh(newMesh); } } }
//IOpsCommand public void Run(OpsContext context, OpsStatement statement) { OpsConsole.WriteLine("Resetting the entire context"); context.Reset(); }