// Use this for initialization
void Start()
{
// Dimensions of our volume.
int width = 100;
int height = 10;
int depth = 100;
TerrainVolumeData volumeData = VolumeData.CreateEmptyVolumeData <TerrainVolumeData>(new Region(0, 0, 0, width, height, depth));
// Let's keep the allocation outside of the loop.
MaterialSet materialSet = new MaterialSet();
float simplexNoiseValue = 0f;
simplexNoiseValue += 1.0f;
simplexNoiseValue *= 127.5f;
materialSet.weights[0] = (byte)simplexNoiseValue;
for (int z = 0; z < depth; z++)
{
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
volumeData.SetVoxel(x, y, z, materialSet);
}
}
}
//Add the required volume component.
TerrainVolume terrainVolume = gameObject.AddComponent <TerrainVolume>();
// Set the provided data.
terrainVolume.data = volumeData;
// Add the renderer
gameObject.AddComponent <TerrainVolumeRenderer>();
}
public MaterialSet ProvideNext(ProviderContext context)
{
if (currentIndex > context.CycleLength)
{
currentIndex = 0;
}
var position = 1.0 / context.CycleLength * currentIndex;
var gradientStepSpan = GradientStepData.Sum(step => step.Offset);
var additivestepPercentage = 0d;
MaterialSet interpolatedMaterialSet = Palette.Red;
if (position >= 1)
{
currentIndex++;
return(GradientStepData.Last().MaterialSet);
}
for (var x = 0; x <= GradientStepData.Count - 2; x++)
{
var stepPercentage = GradientStepData[x].Offset / gradientStepSpan;
var stepProgression = position - additivestepPercentage;
var stepProgressionPercentage = stepProgression / stepPercentage;
if (position >= additivestepPercentage && position < (additivestepPercentage + stepPercentage))
{
interpolatedMaterialSet = MediaExtensions.Interpolate(GradientStepData[x].MaterialSet,
GradientStepData[x + 1].MaterialSet, stepProgressionPercentage);
break;
}
additivestepPercentage += stepPercentage;
}
currentIndex++;
return(interpolatedMaterialSet);
}
/// <summary>
/// Calculate and store material quantities for a given element.
/// </summary>
/// <param name="e">The element.</param>
private void CalculateMaterialQuantitiesOfElement(Element e)
{
ElementId elementId = e.Id;
MaterialSet materials = e.Materials;
foreach (Material material in materials)
{
ElementId materialId = material.Id;
double volume = e.GetMaterialVolume(material);
double area = e.GetMaterialArea(material);
if (volume > 0.0 || area > 0.0)
{
StoreMaterialQuantities(materialId, volume, area, m_totalQuantities);
Dictionary <ElementId, MaterialQuantities> quantityPerElement;
bool found = m_quantitiesPerElement.TryGetValue(elementId, out quantityPerElement);
if (found)
{
StoreMaterialQuantities(materialId, volume, area, quantityPerElement);
}
else
{
quantityPerElement = new Dictionary <ElementId, MaterialQuantities>();
StoreMaterialQuantities(materialId, volume, area, quantityPerElement);
m_quantitiesPerElement.Add(elementId, quantityPerElement);
}
}
}
}
//TODO just make this a virtual function in MaterialSet/overriden in MaterialSet
public static MaterialSet Interpolate(MaterialSet a, MaterialSet b, double p)
{
var mixedSet = new AccentedMaterialSet()
{
P050 = Interpolate(a.P050, b.P050, p),
P100 = Interpolate(a.P100, b.P100, p),
P200 = Interpolate(a.P200, b.P200, p),
P300 = Interpolate(a.P300, b.P300, p),
P400 = Interpolate(a.P400, b.P400, p),
P500 = Interpolate(a.P500, b.P500, p),
P600 = Interpolate(a.P600, b.P600, p),
P700 = Interpolate(a.P700, b.P700, p),
P800 = Interpolate(a.P800, b.P800, p),
P900 = Interpolate(a.P900, b.P900, p),
};
if (!(a is AccentedMaterialSet) || !(b is AccentedMaterialSet))
{
return(mixedSet);
}
var aa = (AccentedMaterialSet)a;
var ab = (AccentedMaterialSet)b;
mixedSet.A100 = Interpolate(aa.A100, ab.A100, p);
mixedSet.A200 = Interpolate(aa.A200, ab.A200, p);
mixedSet.A400 = Interpolate(aa.A400, ab.A400, p);
mixedSet.A700 = Interpolate(aa.A700, ab.A700, p);
return(mixedSet);
}
private void drawColourPair(string name, string propName1, string propName2, MaterialSet materialSet)
{
// Get object properties
SerializedProperty prop1 = serializedObject.FindProperty(propName1);
SerializedProperty prop2 = serializedObject.FindProperty(propName2);
// Draw properties
GUILayout.BeginHorizontal();
GUILayout.Label(name, GUILayout.Width(EditorGUIUtility.labelWidth - 2));
if (materialSet.hasColour1)
{
// Limit property values to colour palette size
if (materialSet.colourPalette1.colours.Length > 0 && prop1.intValue >= materialSet.colourPalette1.colours.Length)
{
prop1.intValue = materialSet.colourPalette1.colours.Length - 1;
}
prop1.intValue = EditorGUILayout.Popup("", prop1.intValue, getColourNames(materialSet.colourPalette1), EditorStyles.popup, GUILayout.MaxWidth(71));
GUI.enabled = false;
EditorGUILayout.ColorField(materialSet.colourPalette1.colours.Length > 0 ? materialSet.colourPalette1.colours[prop1.intValue].colour : Color.white, GUILayout.MaxWidth(35));
GUI.enabled = true;
}
if (materialSet.hasColour2)
{
if (materialSet.colourPalette2.colours.Length > 0 && prop2.intValue >= materialSet.colourPalette2.colours.Length)
{
prop2.intValue = materialSet.colourPalette2.colours.Length - 1;
}
prop2.intValue = EditorGUILayout.Popup("", prop2.intValue, getColourNames(materialSet.colourPalette2), EditorStyles.popup, GUILayout.MaxWidth(71));
GUI.enabled = false;
EditorGUILayout.ColorField(materialSet.colourPalette2.colours.Length > 0 ? materialSet.colourPalette2.colours[prop2.intValue].colour : Color.white, GUILayout.MaxWidth(35));
GUI.enabled = true;
}
GUILayout.EndHorizontal();
}
public override void OnStart()
{
base.OnStart();
Current = this;
_terrainMap = new VoxelTerrainMap();
// Build material set
VoxelMaterials = new VoxelMaterialSet.VoxelMaterial[ushort.MaxValue];
foreach (var entry in ((VoxelMaterialSet)MaterialSet.CreateInstance()).Materials)
{
var material = entry.Material;
if (material != null)
{
VoxelMaterials[material.Id] = material;
}
}
// Build initial chunks
for (var y = 0; y < 4; y++)
{
for (var x = -8; x < 8; x++)
{
for (var z = -8; z < 8; z++)
{
_terrainMap.CreateChunk(new Vector3Int(x * 16, y * 16, z * 16));
}
}
}
}
/// <summary>
/// Set random material from MaterialSet
/// </summary>
/// <param name="materialSet">MaterialSet for picking materials</param>
void SetRandomColorFromColorSet(MaterialSet materialSet)
{
if (materialSet)
{
_renderer.material = materialSet.Materials[Random.Range(0, materialSet.Materials.Length)];
}
}
void Start()
{
_renderer = GetComponent <MeshRenderer>();
MaterialSet materialSet = GetMaterialSet();
SetRandomColorFromColorSet(materialSet);
}
public FigureRenderer Load(IArchiveDirectory figureDir, MaterialSetAndVariantOption materialSetOption)
{
SurfaceProperties surfaceProperties = Persistance.Load <SurfaceProperties>(figureDir.File("surface-properties.dat"));
var refinementDirectory = figureDir.Subdirectory("refinement");
var controlMeshDirectory = refinementDirectory.Subdirectory("control");
int[] surfaceMap = controlMeshDirectory.File("surface-map.array").ReadArray <int>();
var refinedMeshDirectory = refinementDirectory.Subdirectory("level-" + surfaceProperties.SubdivisionLevel);
SubdivisionMesh mesh = SubdivisionMeshPersistance.Load(refinedMeshDirectory);
int[] controlFaceMap = refinedMeshDirectory.File("control-face-map.array").ReadArray <int>();
var materialSet = MaterialSet.LoadActive(device, shaderCache, textureCache, dataDir, figureDir, materialSetOption, surfaceProperties);
var materials = materialSet.Materials;
Scatterer scatterer = surfaceProperties.PrecomputeScattering ? Scatterer.Load(device, shaderCache, figureDir, materialSetOption.MaterialSet.Label) : null;
var uvSetName = materials[0].UvSet;
IArchiveDirectory uvSetDirectory = figureDir.Subdirectory("uv-sets").Subdirectory(uvSetName);
var texturedVertexInfos = uvSetDirectory.File("textured-vertex-infos.array").ReadArray <TexturedVertexInfo>();
Quad[] texturedFaces = uvSetDirectory.File("textured-faces.array").ReadArray <Quad>();
var vertexRefiner = new VertexRefiner(device, shaderCache, mesh, texturedVertexInfos);
FigureSurface[] surfaces = FigureSurface.MakeSurfaces(device, materials.Length, texturedFaces, controlFaceMap, surfaceMap, materialSet.FaceTransparencies);
HashSet <int> visitedSurfaceIndices = new HashSet <int>();
List <int> surfaceOrder = new List <int>(surfaces.Length);
bool[] areUnorderedTransparent = new bool[surfaces.Length];
//first add surfaces with an explicity-set render order
foreach (int surfaceIdx in surfaceProperties.RenderOrder)
{
visitedSurfaceIndices.Add(surfaceIdx);
surfaceOrder.Add(surfaceIdx);
areUnorderedTransparent[surfaceIdx] = false;
}
//then add any remaining surfaces
for (int surfaceIdx = 0; surfaceIdx < surfaces.Length; ++surfaceIdx)
{
if (visitedSurfaceIndices.Contains(surfaceIdx))
{
continue;
}
surfaceOrder.Add(surfaceIdx);
areUnorderedTransparent[surfaceIdx] = true;
}
var isOneSided = figureDir.Name == "genesis-3-female"; //hack
return(new FigureRenderer(device, shaderCache, scatterer, vertexRefiner, materialSet, surfaces, isOneSided, surfaceOrder.ToArray(), areUnorderedTransparent));
}
public void Update()
{
if (Record.Record != null)
{
if (Record.Record.Dimensions != Vector2.zero && !ZAligned)
{
ScaleTarget.localScale = new Vector3(originalScale.x * Record.Record.Dimensions.aspect(), originalScale.y, 1) * ScaleFactor;
}
if (Record.Record.Dimensions != Vector2.zero && ZAligned)
{
ScaleTarget.localScale = new Vector3(1, originalScale.y, originalScale.x * Record.Record.Dimensions.aspect()) * ScaleFactor;
}
var shouldSetMaterial = false;
if (Record.Record.Texture && Record.Record.Texture != prevTex)
{
var mats = ImageReader.MaterialsCache.Get(Record.Record.Texture);
if (mats == null)
{
mats = new MaterialSet {
TallMaterial = new Material(TallMaterial),
LongMaterial = new Material(LongMaterial),
WiggleMaterial = new Material(WiggleMaterial),
};
mats.SetTexture(Record.Record.Texture);
mats.SetFlip(Record.Record.Facing == ImageFacing.Left);
ImageReader.MaterialsCache[Record.Record.Texture] = mats;
}
shouldSetMaterial = true;
prevTex = Record.Record.Texture;
}
shouldSetMaterial |= prevWiggling != IsWiggling;
if (shouldSetMaterial)
{
var mats = ImageReader.MaterialsCache.Get(Record.Record.Texture);
var isWiggling = IsWiggling || ImageReader.Inst.ALWAYS_WIGGLE;
renderer.material = isWiggling ? mats.WiggleMaterial : Record.Record.IsTall ? mats.TallMaterial : mats.LongMaterial;
renderer.SetPropertyBlock(Properties);
}
prevWiggling = IsWiggling;
glimmerParticles.enableEmission(IsGlimmering);
var gpcol = glimmerParticles.colorOverLifetime;
var gpcolc = gpcol.color;
var gpcolcg = gpcolc.gradient;
var gpcolcgc = gpcolc.gradient.colorKeys;
gpcolcgc[0].color = Record.Record.Color2;
gpcolcgc[1].color = Record.Record.Color1;
gpcolcgc[2].color = Record.Record.Color2;
gpcolcgc[3].color = Record.Record.Color1;
gpcolcg.colorKeys = gpcolcgc;
gpcolc.gradient = gpcolcg;
gpcol.color = gpcolc;
}
if (Record.Record == null || Record.Record.Dimensions == Vector2.zero)
{
ScaleTarget.localScale = Vector3.one * ScaleFactor;
}
}
public override SolidColorBrush GetMaterial(MaterialSet materialSet)
{
var material1 = materialSet.FromLuminosity(Luminosity1);
var material2 = materialSet.FromLuminosity(Luminosity2);
var interpolatedMaterial = material1.Blend(material2, Progression);
return(interpolatedMaterial.WithOpacity(Opacity));
}
private static MaterialSet createMaterialSetAssetForSubFolder(string pSubfolder)
{
Debug.Log("Processing " + pSubfolder);
//first create an instance of a MaterialSet scriptable object
MaterialSet materialSet = createMaterialSetForSubFolder(pSubfolder);
//and then store it in an asset
AssetDatabase.CreateAsset(materialSet, pSubfolder + ".asset");
return(materialSet);
}
/// Sets the material weights of the specified position.
/**
* \param x The 'x' position of the voxel to set.
* \param y The 'y' position of the voxel to set.
* \param z The 'z' position of the voxel to set.
* \param materialSet The material weights the voxel should be set to.
*/
public void SetVoxel(int x, int y, int z, MaterialSet materialSet)
{
if (volumeHandle.HasValue)
{
if (x >= enclosingRegion.lowerCorner.x && y >= enclosingRegion.lowerCorner.y && z >= enclosingRegion.lowerCorner.z &&
x <= enclosingRegion.upperCorner.x && y <= enclosingRegion.upperCorner.y && z <= enclosingRegion.upperCorner.z)
{
CubiquityDLL.SetVoxelMC(volumeHandle.Value, x, y, z, materialSet);
}
}
}
void RemoveWeight(int xPos, int yPos, int zPos)
{
int a = terrainVolume.data.GetVoxel(xPos, yPos, zPos).weights [3];
byte b = (byte)(a - 1);
if (b >= (byte)0)
{
MaterialSet ms = new MaterialSet();
ms.weights [3] = b;
terrainVolume.data.SetVoxel(xPos, yPos, zPos, ms);
}
}
void AddWeight(int xPos, int yPos, int zPos)
{
int a = terrainVolume.data.GetVoxel(xPos, yPos, zPos).weights [3];
a = a + 1;
if (a <= 300)
{
MaterialSet ms = new MaterialSet();
ms.weights [3] = (byte)a;
terrainVolume.data.SetVoxel(xPos, yPos, zPos, ms);
}
}
// Use this for initialization
void Start()
{
// Dimensions of our volume.
int width = 64;
int height = 64;
int depth = 64;
TerrainVolumeData volumeData = VolumeData.CreateEmptyVolumeData <TerrainVolumeData>(new Region(0, 0, 0, width - 1, height - 1, depth - 1));
float noiseScale = 32.0f;
float invNoiseScale = 1.0f / noiseScale;
// Let's keep the allocation outside of the loop.
MaterialSet materialSet = new MaterialSet();
// Iterate over each voxel and assign a value to it
for (int z = 0; z < depth; z++)
{
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
// Simplex noise is quite high frequency. We scale the sample position to reduce this.
float sampleX = (float)x * invNoiseScale;
float sampleY = (float)y * invNoiseScale;
float sampleZ = (float)z * invNoiseScale;
// Get the noise value for the current position.
// Returned value should be in the range -1 to +1.
float simplexNoiseValue = SimplexNoise.Noise.Generate(sampleX, sampleY, sampleZ);
// Cubiquity material weights need to be in the range 0 - 255.
simplexNoiseValue += 1.0f; // Now it's 0.0 to 2.0
simplexNoiseValue *= 127.5f; // Now it's 0.0 to 255.0
materialSet.weights[0] = (byte)simplexNoiseValue;
// We can now write our computed voxel value into the volume.
volumeData.SetVoxel(x, y, z, materialSet);
}
}
}
//Add the required volume component.
TerrainVolume terrainVolume = gameObject.AddComponent <TerrainVolume>();
// Set the provided data.
terrainVolume.data = volumeData;
// Add the renderer
gameObject.AddComponent <TerrainVolumeRenderer>();
}
/// <summary>
/// Load MaterialSet from Resources
/// </summary>
/// <returns>MaterialSet</returns>
MaterialSet GetMaterialSet()
{
//Using different materials instead of setting random color - for case of Instancing (better for performance)
//All balls with same material will be drown in 1 draw call
//Also it will allow you to use some special materials on some balls
MaterialSet[] materialSets = Resources.LoadAll <MaterialSet>("Settings");
if (materialSets.Length > 0)
{
//Dummy get first color set
MaterialSet materialSet = materialSets[0];
return(materialSet);
}
return(null);
}
private static MaterialSet createMaterialSetForSubFolder(string pSubfolder)
{
//get the last path from the subfolder, that will be the name of our material set
string materialSetName = Path.GetFileName(pSubfolder);
Debug.Log("Creating material set for:" + materialSetName);
MaterialSet materialSet = ScriptableObject.CreateInstance <MaterialSet>();
//turn MyMaterialSet into "My Material Set"
string[] nameParts = Regex.Split(materialSetName, @"(?<!^)(?=[A-Z])");
materialSet.description = (nameParts.Length == 0)?materialSetName:string.Join(" ", nameParts);
materialSet.materials = getAllMaterialsInFolder(pSubfolder);
return(materialSet);
}
/// Gets the material weights of the specified position.
/**
* \param x The 'x' position of the voxel to get.
* \param y The 'y' position of the voxel to get.
* \param z The 'z' position of the voxel to get.
* \return The material weights of the voxel.
*/
public MaterialSet GetVoxel(int x, int y, int z)
{
MaterialSet materialSet;
if (volumeHandle.HasValue)
{
CubiquityDLL.GetVoxelMC(volumeHandle.Value, x, y, z, out materialSet);
}
else
{
// Should maybe throw instead?
materialSet = new MaterialSet();
}
return(materialSet);
}
private void DestroyVoxels(int xPos, int yPos, int zPos)
{
int aux = Mathf.Max(RangeX, RangeY, RangeZ);
int rangeSquared = aux * aux;
MaterialSet emptyMaterialSet = new MaterialSet();
MaterialSet fillMaterialSet = new MaterialSet();
fillMaterialSet.weights[0] = 255;
fillMaterialSet.weights[1] = 255;
fillMaterialSet.weights[2] = 255;
for (int z = zPos - RangeZ; z < zPos + RangeZ; z++) {
for (int y = yPos - RangeY; y < yPos + RangeY; y++) {
for (int x = xPos - RangeX; x < xPos + RangeX; x++) {
int xDistance = x - xPos;
int yDistance = y - yPos;
int zDistance = z - zPos;
int distSquared = 0;
if (Euclidean) {
distSquared = SqrEuclideanDistance(xDistance, yDistance, zDistance);
}
else {
distSquared = ManhattanDistance(xDistance, yDistance, zDistance);
}
if (distSquared < rangeSquared) {
if (Erase) {
_terrainVolume.data.SetVoxel(x, y, z, emptyMaterialSet);
}
else {
_terrainVolume.data.SetVoxel(x, y, z, fillMaterialSet);
}
}
}
}
}
TerrainVolumeEditor.BlurTerrainVolume(_terrainVolume,
new Region(
xPos - RangeX + SmoothFactor,
yPos - RangeY + SmoothFactor,
zPos - RangeZ + SmoothFactor,
xPos + RangeX + SmoothFactor,
yPos + RangeY + SmoothFactor,
zPos + RangeZ + SmoothFactor)
);
}
public FigureRenderer(
Device device, ShaderCache shaderCache, Scatterer scatterer, VertexRefiner vertexRefiner, MaterialSet materialSet, FigureSurface[] surfaces,
bool isOneSided, int[] surfaceOrder, bool[] areUnorderedTranparent)
{
this.scatterer = scatterer;
this.vertexRefiner = vertexRefiner;
this.materialSet = materialSet;
this.surfaces = surfaces;
this.isOneSided = isOneSided;
this.surfaceOrder = surfaceOrder;
this.areUnorderedTransparent = areUnorderedTranparent;
var vertexShaderAndBytecode = shaderCache.GetVertexShader <FigureRenderer>("figure/rendering/Figure");
this.vertexShader = vertexShaderAndBytecode;
this.inputLayout = new InputLayout(device, vertexShaderAndBytecode.Bytecode, vertexRefiner.RefinedVertexBufferInputElements);
falseDepthVertexShader = shaderCache.GetVertexShader <FigureRenderer>("figure/rendering/Figure-FalseDepth");
}
void AddVoxels(int xPos, int yPos, int zPos, int range)
{
MaterialSet materialSet = new MaterialSet();
materialSet.weights[3] = (byte)weight;
int rangeSquared = range * range;
List <Vector3i> voxelsToDelete = new List <Vector3i>();
for (int z = zPos - range; z <= zPos + range; z++)
{
for (int y = yPos - range; y <= yPos + range; y++)
{
for (int x = xPos - range; x <= xPos + range; x++)
{
// // Compute the distance from the current voxel to the center of our explosion.
// int xDistance = x - xPos;
// int yDistance = y - yPos;
// int zDistance = z - zPos;
//
// // Working with squared distances avoids costly square root operations.
// int distSquared = xDistance * xDistance + yDistance * yDistance + zDistance * zDistance;
// We're iterating over a cubic region, but we want our explosion to be spherical. Therefore
// we only further consider voxels which are within the required range of our explosion center.
// The corners of the cubic region we are iterating over will fail the following test.
// if(distSquared < rangeSquared)
// {
Vector3i voxel = new Vector3i(x, y, z);
voxelsToDelete.Add(voxel);
// }
}
}
}
foreach (Vector3i voxel in voxelsToDelete) // Loop through List with foreach
{
coloredCubesVolume.data.SetVoxel(voxel.x, voxel.y, voxel.z, color);
terrainVolume.data.SetVoxel(voxel.x, voxel.y, voxel.z, materialSet);
}
//CreateTerrain ();
}
void AddVoxels(int xPos, int yPos, int zPos, int range = 2)
{
// Initialise outside the loop, but we'll use it later.
int rangeSquared = range * range;
// Iterage over every voxel in a cubic region defined by the received position (the center) and
// the range. It is quite possible that this will be hundreds or even thousands of voxels.
for (int z = zPos - range; z < zPos + range; z++)
{
for (int y = yPos - range; y < yPos + range; y++)
{
for (int x = xPos - range; x < xPos + range; x++)
{
// Compute the distance from the current voxel to the center of our explosion.
int xDistance = x + xPos;
int yDistance = y + yPos;
int zDistance = z + zPos;
float noiseScale = 32.0f;
float invNoiseScale = 1.0f / noiseScale;
float sampleX = (float)xPos * invNoiseScale;
float sampleY = (float)yPos * invNoiseScale;
float sampleZ = (float)zPos * invNoiseScale;
MaterialSet materialSet = new MaterialSet();
materialSet.weights[0] = (byte)255;
// Working with squared distances avoids costly square root operations.
int distSquared = xDistance * xDistance + yDistance * yDistance + zDistance * zDistance;
// We're iterating over a cubic region, but we want our explosion to be spherical. Therefore
// we only further consider voxels which are within the required range of our explosion center.
// The corners of the cubic region we are iterating over will fail the following test.
if (distSquared > rangeSquared)
{
terrainVolume.data.SetVoxel(x, y, z, materialSet);
}
}
}
}
}
void DestroyVoxels(int xPos, int yPos, int zPos, int range)
{
// Initialise outside the loop, but we'll use it later.
int rangeSquared = range * range;
MaterialSet emptyMaterialSet = new MaterialSet();
// Iterage over every voxel in a cubic region defined by the received position (the center) and
// the range. It is quite possible that this will be hundreds or even thousands of voxels.
for (int z = zPos - range; z < zPos + range; z++)
{
for (int y = yPos - range; y < yPos + range; y++)
{
for (int x = xPos - range; x < xPos + range; x++)
{
// Compute the distance from the current voxel to the center of our explosion.
int xDistance = x - xPos;
int yDistance = y - yPos;
int zDistance = z - zPos;
// Working with squared distances avoids costly square root operations.
int distSquared = xDistance * xDistance + yDistance * yDistance + zDistance * zDistance;
// We're iterating over a cubic region, but we want our explosion to be spherical. Therefore
// we only further consider voxels which are within the required range of our explosion center.
// The corners of the cubic region we are iterating over will fail the following test.
if (distSquared < rangeSquared)
{
terrainVolume.data.SetVoxel(x, y, z, emptyMaterialSet);
}
}
}
}
range += 2;
TerrainVolumeEditor.BlurTerrainVolume(terrainVolume, new Region(xPos - range, yPos - range, zPos - range, xPos + range, yPos + range, zPos + range));
//TerrainVolumeEditor.BlurTerrainVolume(terrainVolume, new Region(xPos - range, yPos - range, zPos - range, xPos + range, yPos + range, zPos + range));
//TerrainVolumeEditor.BlurTerrainVolume(terrainVolume, new Region(xPos - range, yPos - range, zPos - range, xPos + range, yPos + range, zPos + range));
}
public FigureRenderer(
Device device, ShaderCache shaderCache, Scatterer scatterer, VertexRefiner vertexRefiner, MaterialSet materialSet, FigureSurface[] surfaces,
bool isOneSided, int[] surfaceOrder, bool[] areUnorderedTranparent, TexturedVertexInfo[] texturedVertexInfos)
{
this.device = device;
this.scatterer = scatterer;
this.vertexRefiner = vertexRefiner;
this.materialSet = materialSet;
this.surfaces = surfaces;
this.isOneSided = isOneSided;
this.surfaceOrder = surfaceOrder;
this.areUnorderedTransparent = areUnorderedTranparent;
var vertexShaderAndBytecode = shaderCache.GetVertexShader <FigureRenderer>("figure/rendering/Figure");
this.vertexShader = vertexShaderAndBytecode;
this.inputLayout = new InputLayout(device, vertexShaderAndBytecode.Bytecode, vertexRefiner.RefinedVertexBufferInputElements);
falseDepthVertexShader = shaderCache.GetVertexShader <FigureRenderer>("figure/rendering/Figure-FalseDepth");
primaryTexturedVertexInfos = texturedVertexInfos;
texturedVertexInfoPairsView = BufferUtilities.ToStructuredBufferView(device, TexturedVertexInfoPair.Interleave(primaryTexturedVertexInfos, null));
}
public static void SetTheme(DependencyObject i, MaterialSet v) => i.Set(ThemeProperty, v);
public override SolidColorBrush GetMaterial(MaterialSet materialSet) => LiteralMaterial.WithOpacity(Opacity);
public AlternatingMaterialProvider(MaterialSet materialSet1, MaterialSet materialSet2)
{
MaterialSet1 = materialSet1;
MaterialSet2 = materialSet2;
}
public void Init()
{
Renderer = GetComponent <MeshRenderer>();
MaterialSet = new MaterialSet(Renderer.material);
}
public Model(EndianBinaryReader er)
{
long basepos = er.BaseStream.Position;
size = er.ReadUInt32();
ofsSbc = er.ReadUInt32();
ofsMat = er.ReadUInt32();
ofsShp = er.ReadUInt32();
ofsEvpMtx = er.ReadUInt32();
info = new ModelInfo(er);
nodes = new NodeSet(er);
long curpos = er.BaseStream.Position;
er.BaseStream.Position = ofsSbc + basepos;
sbc = er.ReadBytes((int)(ofsMat - ofsSbc));
er.BaseStream.Position = curpos;
er.BaseStream.Position = ofsMat + basepos;
materials = new MaterialSet(er);
er.BaseStream.Position = ofsShp + basepos;
shapes = new ShapeSet(er);
if (ofsEvpMtx != size && ofsEvpMtx != 0)
{
er.BaseStream.Position = ofsEvpMtx + basepos;
evpMatrices = new EvpMatrices(er, nodes.dict.numEntry);
}
/*long modelset = er.GetMarker("ModelSet");
er.ClearMarkers();
curpos = er.BaseStream.Position;
er.BaseStream.Position = modelset;
er.SetMarkerOnCurrentOffset("ModelSet");
er.BaseStream.Position = curpos;*/
}
public static void SetTheme(DependencyObject i, MaterialSet v) => i.Set(ThemeProperty, v);
public static void SetVoxelMC(uint volumeHandle, int x, int y, int z, MaterialSet materialSet)
{
Validate(cuSetVoxelMC(volumeHandle, x, y, z, materialSet));
}
