/// <summary> /// Create a Particle definition. /// </summary> /// <param name="vgoParticle"></param> /// <returns></returns> protected virtual ParticleDefinition CreateParticleDefinition(VGO_materials_particle vgoParticle) { ParticleDefinition particleDefinition = new ParticleDefinition() { RenderMode = (UniStandardParticle.BlendMode)vgoParticle.renderMode, ColorMode = (UniStandardParticle.ColorMode)vgoParticle.colorMode, FlipBookMode = (UniStandardParticle.FlipBookMode)vgoParticle.flipBookMode, CullMode = vgoParticle.cullMode, SoftParticlesEnabled = vgoParticle.softParticlesEnabled, SoftParticleFadeParams = ArrayConverter.ToVector4(vgoParticle.softParticleFadeParams), CameraFadingEnabled = vgoParticle.cameraFadingEnabled, CameraFadeParams = ArrayConverter.ToVector4(vgoParticle.cameraFadeParams), DistortionEnabled = vgoParticle.distortionEnabled, GrabTexture = GetTexture(UniStandardParticle.Utils.PropGrabTexture, vgoParticle.grabTextureIndex), DistortionStrengthScaled = vgoParticle.distortionStrengthScaled, DistortionBlend = vgoParticle.distortionBlend, ColorAddSubDiff = ArrayConverter.ToColor(vgoParticle.colorAddSubDiff, gamma: true), MainTex = GetTexture(UniStandardParticle.Utils.PropMainTex, vgoParticle.mainTexIndex), MainTexSt = ArrayConverter.ToVector4(vgoParticle.mainTexSt), Color = ArrayConverter.ToColor(vgoParticle.color, gamma: true), Cutoff = vgoParticle.cutoff, MetallicGlossMap = GetTexture(UniStandardParticle.Utils.PropMetallicGlossMap, vgoParticle.metallicGlossMapIndex), Metallic = vgoParticle.metallic, Glossiness = vgoParticle.glossiness, BumpMap = GetTexture(UniStandardParticle.Utils.PropBumpMap, vgoParticle.bumpMapIndex), BumpScale = vgoParticle.bumpScale, LightingEnabled = vgoParticle.lightingEnabled, EmissionEnabled = vgoParticle.emissionEnabled, EmissionColor = ArrayConverter.ToColor(vgoParticle.emissionColor, gamma: true), EmissionMap = GetTexture(UniStandardParticle.Utils.PropEmissionMap, vgoParticle.emissionMapIndex), }; return(particleDefinition); }
/// <summary> /// Set ParticleSystem rotationBySpeed field value. /// </summary> /// <param name="particleSystem"></param> /// <param name="vgoModule"></param> protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_RotationBySpeedModule vgoModule) { if (vgoModule == null) { return; } RotationBySpeedModule module = particleSystem.rotationBySpeed; module.enabled = vgoModule.enabled; module.separateAxes = vgoModule.separateAxes; if (vgoModule.separateAxes) { module.x = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.x); module.y = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.y); module.z = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.z); module.xMultiplier = vgoModule.xMultiplier; module.yMultiplier = vgoModule.yMultiplier; module.zMultiplier = vgoModule.zMultiplier; } else { module.x = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.x); module.xMultiplier = vgoModule.xMultiplier; } module.range = ArrayConverter.ToVector2(vgoModule.range); }
/// <summary> /// Set ParticleSystem shape field value. /// </summary> /// <param name="particleSystem"></param> /// <param name="vgoModule"></param> /// <param name="textureItemList"></param> protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_ShapeModule vgoModule, IList <TextureItem> textureItemList) { if (vgoModule == null) { return; } ShapeModule module = particleSystem.shape; module.enabled = vgoModule.enabled; module.shapeType = vgoModule.shapeType; module.angle = vgoModule.angle; module.radius = vgoModule.radius; module.donutRadius = vgoModule.donutRadius; module.radiusMode = vgoModule.radiusMode; module.radiusSpread = vgoModule.radiusSpread; module.radiusSpeed = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.radiusSpeed); module.radiusSpeedMultiplier = vgoModule.radiusSpeedMultiplier; module.radiusThickness = vgoModule.radiusThickness; module.boxThickness = ArrayConverter.ToVector3(vgoModule.boxThickness, reverseZ: true); module.arc = vgoModule.arc; module.arcMode = vgoModule.arcMode; module.arcSpread = vgoModule.arcSpread; module.arcSpeed = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.arcSpeed); module.arcSpeedMultiplier = vgoModule.arcSpeedMultiplier; module.length = vgoModule.length; module.meshShapeType = vgoModule.meshShapeType; module.meshSpawnMode = vgoModule.meshSpawnMode; module.meshSpawnSpread = vgoModule.meshSpawnSpread; module.meshSpawnSpeed = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.meshSpawnSpeed); module.meshSpawnSpeedMultiplier = vgoModule.meshSpawnSpeedMultiplier; //module.mesh; //module.meshRenderer; //module.skinnedMeshRenderer; module.useMeshMaterialIndex = vgoModule.useMeshMaterialIndex; module.meshMaterialIndex = vgoModule.meshMaterialIndex; module.useMeshColors = vgoModule.useMeshColors; //module.sprite; //module.spriteRenderer; module.normalOffset = vgoModule.normalOffset; if ((textureItemList != null) && (-1 < vgoModule.textureIndex) && (vgoModule.textureIndex < textureItemList.Count)) { module.texture = textureItemList[vgoModule.textureIndex].Texture; } module.textureClipChannel = vgoModule.textureClipChannel; module.textureClipThreshold = vgoModule.textureClipThreshold; module.textureColorAffectsParticles = vgoModule.textureColorAffectsParticles; module.textureAlphaAffectsParticles = vgoModule.textureAlphaAffectsParticles; module.textureBilinearFiltering = vgoModule.textureBilinearFiltering; module.textureUVChannel = vgoModule.textureUVChannel; module.position = ArrayConverter.ToVector3(vgoModule.position, reverseZ: true); module.rotation = ArrayConverter.ToVector3(vgoModule.rotation, reverseZ: true); module.scale = ArrayConverter.ToVector3(vgoModule.scale); module.alignToDirection = vgoModule.alignToDirection; module.randomPositionAmount = vgoModule.randomPositionAmount; module.sphericalDirectionAmount = vgoModule.sphericalDirectionAmount; module.randomDirectionAmount = vgoModule.randomDirectionAmount; }
/// <summary> /// Set Collider field value. /// </summary> /// <param name="collider"></param> /// <param name="vgoCollider"></param> public static void SetComponentValue(Collider collider, VGO_Collider vgoCollider) { if (collider == null) { return; } if (vgoCollider == null) { return; } Type type = collider.GetType(); if (type == typeof(BoxCollider)) { var boxCollider = collider as BoxCollider; if (vgoCollider.type == ColliderType.Box) { boxCollider.enabled = vgoCollider.enabled; boxCollider.isTrigger = vgoCollider.isTrigger; boxCollider.center = ArrayConverter.ToVector3(vgoCollider.center, reverseZ: true); boxCollider.size = ArrayConverter.ToVector3(vgoCollider.size); boxCollider.sharedMaterial = VgoPhysicMaterialConverter.ToPhysicMaterial(vgoCollider.physicMaterial); } } else if (type == typeof(CapsuleCollider)) { var capsuleCollider = collider as CapsuleCollider; if (vgoCollider.type == ColliderType.Capsule) { capsuleCollider.enabled = vgoCollider.enabled; capsuleCollider.isTrigger = vgoCollider.isTrigger; capsuleCollider.center = ArrayConverter.ToVector3(vgoCollider.center, reverseZ: true); capsuleCollider.radius = vgoCollider.radius; capsuleCollider.height = vgoCollider.height; capsuleCollider.direction = vgoCollider.direction; capsuleCollider.sharedMaterial = VgoPhysicMaterialConverter.ToPhysicMaterial(vgoCollider.physicMaterial); } } else if (type == typeof(SphereCollider)) { var sphereCollider = collider as SphereCollider; if (vgoCollider.type == ColliderType.Sphere) { sphereCollider.enabled = vgoCollider.enabled; sphereCollider.isTrigger = vgoCollider.isTrigger; sphereCollider.center = ArrayConverter.ToVector3(vgoCollider.center, reverseZ: true); sphereCollider.radius = vgoCollider.radius; sphereCollider.sharedMaterial = VgoPhysicMaterialConverter.ToPhysicMaterial(vgoCollider.physicMaterial); } } }
/// <summary> /// Set ParticleSystem colorOverLifetime field value. /// </summary> /// <param name="particleSystem"></param> /// <param name="vgoModule"></param> protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_ColorBySpeedModule vgoModule) { if (vgoModule == null) { return; } ColorBySpeedModule module = particleSystem.colorBySpeed; module.enabled = vgoModule.enabled; module.color = VgoParticleSystemMinMaxGradientConverter.CreateMinMaxGradient(vgoModule.color); module.range = ArrayConverter.ToVector2(vgoModule.range); }
/// <summary> /// Set Light parameter. /// </summary> /// <param name="light"></param> /// <param name="vgoLight"></param> public static void SetComponentValue(Light light, VGO_Light vgoLight) { if (light == null) { return; } if (vgoLight == null) { return; } switch (vgoLight.type) { case LightType.Spot: case LightType.Directional: case LightType.Point: case LightType.Rectangle: case LightType.Disc: break; default: return; } light.enabled = vgoLight.enabled; light.type = vgoLight.type; light.color = ArrayConverter.ToColor(vgoLight.color, gamma: true); light.intensity = vgoLight.intensity; light.bounceIntensity = vgoLight.bounceIntensity; light.renderMode = vgoLight.renderMode; light.cullingMask = vgoLight.cullingMask; #if UNITY_EDITOR light.lightmapBakeType = vgoLight.lightmapBakeType; #endif switch (vgoLight.type) { case LightType.Spot: light.shape = vgoLight.shape; light.range = vgoLight.range; light.spotAngle = vgoLight.spotAngle; break; case LightType.Point: light.range = vgoLight.range; break; #if UNITY_EDITOR case LightType.Rectangle: light.areaSize = ArrayConverter.ToVector2(vgoLight.areaSize); break; case LightType.Disc: light.areaSize = new Vector2(vgoLight.areaRadius, 1.0f); break; #endif default: break; } light.shadows = vgoLight.shadows; #if UNITY_EDITOR // Baked Shadows if ((vgoLight.lightmapBakeType == LightmapBakeType.Baked) || (vgoLight.lightmapBakeType == LightmapBakeType.Mixed)) { if (vgoLight.shadows == LightShadows.Soft) { switch (vgoLight.type) { case LightType.Spot: case LightType.Point: light.shadowRadius = vgoLight.shadowRadius; break; case LightType.Directional: light.shadowAngle = vgoLight.shadowAngle; break; default: break; } } } #endif // Realtime Shadows if ((vgoLight.lightmapBakeType == LightmapBakeType.Realtime) || (vgoLight.lightmapBakeType == LightmapBakeType.Mixed)) { if ((vgoLight.type == LightType.Directional) || (vgoLight.type == LightType.Point)) { light.shadowStrength = vgoLight.shadowStrength; light.shadowResolution = vgoLight.shadowResolution; light.shadowBias = vgoLight.shadowBias; light.shadowNormalBias = vgoLight.shadowNormalBias; light.shadowNearPlane = vgoLight.shadowNearPlane; } } }
/// <summary> /// Create a MToon definition. /// </summary> /// <param name="mtoon"></param> /// <returns></returns> protected virtual MToonDefinition CreateMtoonDefinition(VRMC_materials_mtoon mtoon) { MToonDefinition mtoonDefinition = new MToonDefinition(); // Meta mtoonDefinition.Meta = new MetaDefinition() { VersionNumber = MToon.Utils.VersionNumber, Implementation = MToon.Utils.Implementation, }; // Rendering mtoonDefinition.Rendering = new RenderingDefinition() { RenderMode = (MToon.RenderMode)mtoon.renderMode, CullMode = (MToon.CullMode)mtoon.cullMode, RenderQueueOffsetNumber = mtoon.renderQueueOffsetNumber, }; // Color mtoonDefinition.Color = new ColorDefinition() { LitColor = ArrayConverter.ToColor(mtoon.litFactor, gamma: true), LitMultiplyTexture = GetTexture(MToon.Utils.PropMainTex, mtoon.litMultiplyTexture), ShadeColor = ArrayConverter.ToColor(mtoon.shadeFactor, gamma: true), ShadeMultiplyTexture = GetTexture(MToon.Utils.PropShadeTexture, mtoon.shadeMultiplyTexture), CutoutThresholdValue = mtoon.cutoutThresholdFactor, }; // Lighting mtoonDefinition.Lighting = new LightingDefinition(); mtoonDefinition.Lighting.LitAndShadeMixing = new LitAndShadeMixingDefinition() { ShadingShiftValue = mtoon.shadingShiftFactor, ShadingToonyValue = mtoon.shadingToonyFactor, ShadowReceiveMultiplierValue = mtoon.shadowReceiveMultiplierFactor, ShadowReceiveMultiplierMultiplyTexture = GetTexture(MToon.Utils.PropReceiveShadowTexture, mtoon.shadowReceiveMultiplierMultiplyTexture), LitAndShadeMixingMultiplierValue = mtoon.litAndShadeMixingMultiplierFactor, LitAndShadeMixingMultiplierMultiplyTexture = GetTexture(MToon.Utils.PropShadingGradeTexture, mtoon.litAndShadeMixingMultiplierMultiplyTexture), }; mtoonDefinition.Lighting.LightingInfluence = new LightingInfluenceDefinition() { LightColorAttenuationValue = mtoon.lightColorAttenuationFactor, GiIntensityValue = mtoon.giIntensityFactor, }; mtoonDefinition.Lighting.Normal = new NormalDefinition() { NormalTexture = GetTexture(MToon.Utils.PropBumpMap, mtoon.normalTexture), NormalScaleValue = mtoon.normalScaleFactor, }; // Emission mtoonDefinition.Emission = new EmissionDefinition() { EmissionColor = ArrayConverter.ToColor(mtoon.emissionFactor, gamma: true), EmissionMultiplyTexture = GetTexture(MToon.Utils.PropEmissionMap, mtoon.emissionMultiplyTexture), }; // MatCap mtoonDefinition.MatCap = new MatCapDefinition() { AdditiveTexture = GetTexture(MToon.Utils.PropSphereAdd, mtoon.additiveTexture), }; // Rim mtoonDefinition.Rim = new RimDefinition() { RimColor = ArrayConverter.ToColor(mtoon.rimFactor, gamma: true), RimMultiplyTexture = GetTexture(MToon.Utils.PropRimTexture, mtoon.rimMultiplyTexture), RimLightingMixValue = mtoon.rimLightingMixFactor, RimFresnelPowerValue = mtoon.rimFresnelPowerFactor, RimLiftValue = mtoon.rimLiftFactor, }; // Outline mtoonDefinition.Outline = new OutlineDefinition() { OutlineWidthMode = (MToon.OutlineWidthMode)mtoon.outlineWidthMode, OutlineWidthValue = mtoon.outlineWidthFactor, OutlineWidthMultiplyTexture = GetTexture(MToon.Utils.PropOutlineWidthTexture, mtoon.outlineWidthMultiplyTexture), OutlineScaledMaxDistanceValue = mtoon.outlineScaledMaxDistanceFactor, OutlineColorMode = (MToon.OutlineColorMode)mtoon.outlineColorMode, OutlineColor = ArrayConverter.ToColor(mtoon.outlineFactor, gamma: true), OutlineLightingMixValue = mtoon.outlineLightingMixFactor, }; // Texture Option mtoonDefinition.TextureOption = new TextureUvCoordsDefinition() { MainTextureLeftBottomOriginScale = ArrayConverter.ToVector2(mtoon.mainTextureLeftBottomOriginScale), MainTextureLeftBottomOriginOffset = ArrayConverter.ToVector2(mtoon.mainTextureLeftBottomOriginOffset), UvAnimationMaskTexture = GetTexture(MToon.Utils.PropUvAnimMaskTexture, mtoon.uvAnimationMaskTexture), UvAnimationScrollXSpeedValue = mtoon.uvAnimationScrollXSpeedFactor, UvAnimationScrollYSpeedValue = mtoon.uvAnimationScrollYSpeedFactor, UvAnimationRotationSpeedValue = mtoon.uvAnimationRotationSpeedFactor, }; return(mtoonDefinition); }
/// <summary> /// Create a Unlit material. /// </summary> /// <param name="i"></param> /// <param name="src"></param> /// <param name="hasVertexColor"></param> /// <returns></returns> protected virtual Material CreateUnlitMaterial(int i, glTFMaterial src, bool hasVertexColor) { var shader = m_shaderStore.GetShader(src); var material = new Material(shader); material.name = CreateMaterialName(i, src); #if UNITY_EDITOR material.hideFlags = HideFlags.DontUnloadUnusedAsset; #endif // renderMode switch (src.alphaMode) { case MaterialAlphaMode.OPAQUE: UniGLTF.UniUnlit.Utils.SetRenderMode(material, UniGLTF.UniUnlit.UniUnlitRenderMode.Opaque); break; case MaterialAlphaMode.BLEND: UniGLTF.UniUnlit.Utils.SetRenderMode(material, UniGLTF.UniUnlit.UniUnlitRenderMode.Transparent); break; case MaterialAlphaMode.MASK: UniGLTF.UniUnlit.Utils.SetRenderMode(material, UniGLTF.UniUnlit.UniUnlitRenderMode.Cutout); break; default: UniGLTF.UniUnlit.Utils.SetRenderMode(material, UniGLTF.UniUnlit.UniUnlitRenderMode.Opaque); break; } // culling if (src.doubleSided) { UniGLTF.UniUnlit.Utils.SetCullMode(material, UniGLTF.UniUnlit.UniUnlitCullMode.Off); } else { UniGLTF.UniUnlit.Utils.SetCullMode(material, UniGLTF.UniUnlit.UniUnlitCullMode.Back); } // VColor if (hasVertexColor) { UniGLTF.UniUnlit.Utils.SetVColBlendMode(material, UniGLTF.UniUnlit.UniUnlitVertexColorBlendOp.Multiply); } else { UniGLTF.UniUnlit.Utils.SetVColBlendMode(material, UniGLTF.UniUnlit.UniUnlitVertexColorBlendOp.None); } if (src.pbrMetallicRoughness != null) { // color if (src.pbrMetallicRoughness.baseColorFactor != null) { material.color = ArrayConverter.ToColor(src.pbrMetallicRoughness.baseColorFactor, gamma: true); } // texture if (src.pbrMetallicRoughness.baseColorTexture != null) { var texture = Context.GetTexture(src.pbrMetallicRoughness.baseColorTexture.index); if (texture != null) { material.mainTexture = texture.Texture; } } } if (material.shader.name == ShaderName.UniGLTF_UniUnlit) { UniGLTF.UniUnlit.Utils.ValidateProperties(material, true); return(material); } switch (src.alphaMode) { case MaterialAlphaMode.BLEND: material.SetInt(UniGLTF.UniUnlit.Utils.PropNameBlendMode, (int)BlendMode.Fade); material.SetInt(UniGLTF.UniUnlit.Utils.PropNameSrcBlend, (int)UnityEngine.Rendering.BlendMode.SrcAlpha); material.SetInt(UniGLTF.UniUnlit.Utils.PropNameDstBlend, (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha); material.SetInt(UniGLTF.UniUnlit.Utils.PropNameZWrite, 0); material.DisableKeyword(UniGLTF.UniUnlit.Utils.KeywordAlphaTestOn); material.EnableKeyword(UniGLTF.UniUnlit.Utils.KeywordAlphaBlendOn); material.renderQueue = (int)RenderQueue.Transparent; break; case MaterialAlphaMode.MASK: material.SetFloat(UniGLTF.UniUnlit.Utils.PropNameCutoff, src.alphaCutoff); material.SetInt(UniGLTF.UniUnlit.Utils.PropNameBlendMode, (int)BlendMode.Cutout); material.SetInt(UniGLTF.UniUnlit.Utils.PropNameSrcBlend, (int)UnityEngine.Rendering.BlendMode.One); material.SetInt(UniGLTF.UniUnlit.Utils.PropNameDstBlend, (int)UnityEngine.Rendering.BlendMode.Zero); material.SetInt(UniGLTF.UniUnlit.Utils.PropNameZWrite, 1); material.EnableKeyword(UniGLTF.UniUnlit.Utils.KeywordAlphaTestOn); material.DisableKeyword(UniGLTF.UniUnlit.Utils.KeywordAlphaBlendOn); material.renderQueue = (int)RenderQueue.AlphaTest; break; case MaterialAlphaMode.OPAQUE: default: material.SetInt(UniGLTF.UniUnlit.Utils.PropNameBlendMode, (int)BlendMode.Opaque); material.SetInt(UniGLTF.UniUnlit.Utils.PropNameSrcBlend, (int)UnityEngine.Rendering.BlendMode.One); material.SetInt(UniGLTF.UniUnlit.Utils.PropNameDstBlend, (int)UnityEngine.Rendering.BlendMode.Zero); material.SetInt(UniGLTF.UniUnlit.Utils.PropNameZWrite, 1); material.DisableKeyword(UniGLTF.UniUnlit.Utils.KeywordAlphaTestOn); material.DisableKeyword(UniGLTF.UniUnlit.Utils.KeywordAlphaBlendOn); material.renderQueue = -1; break; } return(material); }
/// <summary> /// Create a Skybox material. /// </summary> /// <param name="i"></param> /// <param name="src"></param> /// <returns></returns> protected virtual Material CreateSkyboxMaterial(int i, glTFMaterial src) { var shader = m_shaderStore.GetShader(src); Material material = new Material(shader); material.name = CreateMaterialName(i, src); #if UNITY_EDITOR material.hideFlags = HideFlags.DontUnloadUnusedAsset; #endif VGO_materials_skybox vgoSkybox = src.extensions.VGO_materials_skybox; switch (shader.name) { case ShaderName.Skybox_6_Sided: UniSkybox.Utils.SetParametersToMaterial(material, new Skybox6SidedDefinition() { Tint = ArrayConverter.ToColor(vgoSkybox.tint, gamma: true), Exposure = vgoSkybox.exposure, Rotation = vgoSkybox.rotation, FrontTex = GetTexture(UniSkybox.Utils.PropFrontTex, vgoSkybox.frontTexIndex), BackTex = GetTexture(UniSkybox.Utils.PropBackTex, vgoSkybox.backTexIndex), LeftTex = GetTexture(UniSkybox.Utils.PropLeftTex, vgoSkybox.leftTexIndex), RightTex = GetTexture(UniSkybox.Utils.PropRightTex, vgoSkybox.rightTexIndex), UpTex = GetTexture(UniSkybox.Utils.PropUpTex, vgoSkybox.upTexIndex), DownTex = GetTexture(UniSkybox.Utils.PropDownTex, vgoSkybox.downTexIndex), }); break; case ShaderName.Skybox_Cubemap: // @todo Tex (Cubemap) UniSkybox.Utils.SetParametersToMaterial(material, new SkyboxCubemapDefinition() { Tint = ArrayConverter.ToColor(vgoSkybox.tint, gamma: true), Exposure = vgoSkybox.exposure, Rotation = vgoSkybox.rotation, Tex = GetCubemap(UniSkybox.Utils.PropTex, vgoSkybox.texIndex), }); break; case ShaderName.Skybox_Panoramic: UniSkybox.Utils.SetParametersToMaterial(material, new SkyboxPanoramicDefinition() { Tint = ArrayConverter.ToColor(vgoSkybox.tint, gamma: true), Exposure = vgoSkybox.exposure, Rotation = vgoSkybox.rotation, MainTex = GetTexture(UniSkybox.Utils.PropMainTex, vgoSkybox.mainTexIndex), Mapping = (Mapping)vgoSkybox.mapping, ImageType = (ImageType)vgoSkybox.imageType, MirrorOnBack = vgoSkybox.mirrorOnBack, Layout = (Layout)vgoSkybox.layout, }); break; case ShaderName.Skybox_Procedural: UniSkybox.Utils.SetParametersToMaterial(material, new SkyboxProceduralDefinition() { SunDisk = (SunDisk)vgoSkybox.sunDisk, SunSize = vgoSkybox.sunSize, SunSizeConvergence = vgoSkybox.sunSizeConvergence, AtmosphereThickness = vgoSkybox.atmosphereThickness, SkyTint = ArrayConverter.ToColor(vgoSkybox.skyTint, gamma: true), GroundColor = ArrayConverter.ToColor(vgoSkybox.groundColor, gamma: true), Exposure = vgoSkybox.exposure, }); break; default: break; } return(material); }
/// <summary> /// Set ParticleSystem main field value. /// </summary> /// <param name="particleSystem"></param> /// <param name="vgoModule"></param> protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_MainModule vgoModule) { if (vgoModule == null) { return; } MainModule module = particleSystem.main; // @notice if (Application.isPlaying == false) { module.duration = vgoModule.duration; } module.loop = vgoModule.loop; module.prewarm = vgoModule.prewarm; module.startDelay = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startDelay); module.startDelayMultiplier = vgoModule.startDelayMultiplier; module.startLifetime = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startLifetime); module.startLifetimeMultiplier = vgoModule.startLifetimeMultiplier; module.startSpeed = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startSpeed); module.startSpeedMultiplier = vgoModule.startSpeedMultiplier; module.startSize3D = vgoModule.startSize3D; if (vgoModule.startSize3D) { module.startSizeX = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startSizeX); module.startSizeY = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startSizeY); module.startSizeZ = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startSizeZ); module.startSizeXMultiplier = vgoModule.startSizeXMultiplier; module.startSizeYMultiplier = vgoModule.startSizeYMultiplier; module.startSizeZMultiplier = vgoModule.startSizeZMultiplier; } else { module.startSize = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startSize); module.startSizeMultiplier = vgoModule.startSizeMultiplier; } module.startRotation3D = vgoModule.startRotation3D; if (vgoModule.startRotation3D) { module.startRotationX = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startRotationX); module.startRotationY = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startRotationY); module.startRotationZ = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startRotationZ); module.startRotationXMultiplier = vgoModule.StartRotationXMultiplier; module.startRotationYMultiplier = vgoModule.StartRotationYMultiplier; module.startRotationZMultiplier = vgoModule.StartRotationZMultiplier; } else { module.startRotation = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.startRotation); module.startRotationMultiplier = vgoModule.StartRotationMultiplier; } module.flipRotation = vgoModule.flipRotation; module.startColor = VgoParticleSystemMinMaxGradientConverter.CreateMinMaxGradient(vgoModule.startColor); module.gravityModifier = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.gravityModifier); module.gravityModifierMultiplier = vgoModule.gravityModifierMultiplier; module.simulationSpace = vgoModule.simulationSpace; module.simulationSpeed = vgoModule.simulationSpeed; VgoTransformConverter.SetComponentValue(module.customSimulationSpace, vgoModule.customSimulationSpace); module.useUnscaledTime = vgoModule.useUnscaledTime; module.scalingMode = vgoModule.scalingMode; module.playOnAwake = vgoModule.playOnAwake; module.emitterVelocityMode = vgoModule.emitterVelocityMode; module.maxParticles = vgoModule.maxParticles; module.stopAction = vgoModule.stopAction; module.cullingMode = vgoModule.cullingMode; module.ringBufferMode = vgoModule.ringBufferMode; if (vgoModule.ringBufferMode == ParticleSystemRingBufferMode.LoopUntilReplaced) { module.ringBufferLoopRange = ArrayConverter.ToVector2(vgoModule.ringBufferLoopRange); } }
/// <summary> /// Set particleSystemRenderer field value. /// </summary> /// <param name="particleSystemRenderer"></param> /// <param name="vgoRenderer"></param> /// <param name="materialList"></param> public virtual void SetComponentValue(ParticleSystemRenderer particleSystemRenderer, VGO_PS_Renderer vgoRenderer, IList <Material> materialList) { if (vgoRenderer == null) { return; } particleSystemRenderer.enabled = vgoRenderer.enabled; particleSystemRenderer.renderMode = vgoRenderer.renderMode; // Billboard particleSystemRenderer.cameraVelocityScale = vgoRenderer.cameraVelocityScale; particleSystemRenderer.velocityScale = vgoRenderer.velocityScale; particleSystemRenderer.lengthScale = vgoRenderer.lengthScale; particleSystemRenderer.normalDirection = vgoRenderer.normalDirection; // Material if ((materialList != null) && (-1 < vgoRenderer.sharedMaterial) && (vgoRenderer.sharedMaterial < materialList.Count)) { particleSystemRenderer.sharedMaterial = materialList[vgoRenderer.sharedMaterial]; } if ((materialList != null) && (-1 < vgoRenderer.trailMaterialIndex) && (vgoRenderer.trailMaterialIndex < materialList.Count)) { particleSystemRenderer.trailMaterial = materialList[vgoRenderer.trailMaterialIndex]; } particleSystemRenderer.sortMode = vgoRenderer.sortMode; particleSystemRenderer.sortingFudge = vgoRenderer.sortingFudge; particleSystemRenderer.minParticleSize = vgoRenderer.minParticleSize; particleSystemRenderer.maxParticleSize = vgoRenderer.maxParticleSize; particleSystemRenderer.alignment = vgoRenderer.alignment; particleSystemRenderer.flip = ArrayConverter.ToVector3(vgoRenderer.flip, reverseZ: true); particleSystemRenderer.allowRoll = vgoRenderer.allowRoll; particleSystemRenderer.pivot = ArrayConverter.ToVector3(vgoRenderer.pivot, reverseZ: true); particleSystemRenderer.maskInteraction = vgoRenderer.maskInteraction; particleSystemRenderer.enableGPUInstancing = vgoRenderer.enableGPUInstancing; // Shadow particleSystemRenderer.shadowCastingMode = vgoRenderer.shadowCastingMode; particleSystemRenderer.receiveShadows = vgoRenderer.receiveShadows; particleSystemRenderer.shadowBias = vgoRenderer.shadowBias; particleSystemRenderer.motionVectorGenerationMode = vgoRenderer.motionVectorGenerationMode; particleSystemRenderer.forceRenderingOff = vgoRenderer.forceRenderingOff; particleSystemRenderer.rendererPriority = vgoRenderer.rendererPriority; particleSystemRenderer.renderingLayerMask = vgoRenderer.renderingLayerMask; particleSystemRenderer.sortingLayerID = vgoRenderer.sortingLayerID; particleSystemRenderer.sortingOrder = vgoRenderer.sortingOrder; particleSystemRenderer.lightProbeUsage = vgoRenderer.lightProbeUsage; particleSystemRenderer.reflectionProbeUsage = vgoRenderer.reflectionProbeUsage; // @notice VgoTransformConverter.SetComponentValue(particleSystemRenderer.probeAnchor, vgoRenderer.probeAnchor); if (particleSystemRenderer.sharedMaterial != null) { //SetVertexStream(particleSystemRenderer, particleSystemRenderer.sharedMaterial); } }