//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();
}
