// 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 SetVoxelMC(uint volumeHandle, int x, int y, int z, MaterialSet materialSet) { Validate(cuSetVoxelMC(volumeHandle, x, y, z, materialSet)); }