//////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// public virtual void Begin(BlendingMode mode) { bmode = mode; if (mode != BlendingMode.None) { BlendState state = states.BlendState; if (mode == BlendingMode.Additive) { state = BlendState.Additive; } if (this.customMatrix.HasValue) { sb.Begin(SpriteSortMode.Immediate, state, states.SamplerState, states.DepthStencilState, states.RasterizerState, null, this.customMatrix.Value); } else { sb.Begin(SpriteSortMode.Immediate, state, states.SamplerState, states.DepthStencilState, states.RasterizerState); } } else { if (this.customMatrix.HasValue) { sb.Begin(SpriteSortMode.Immediate, BlendState.Opaque, states.SamplerState, states.DepthStencilState, states.RasterizerState, null, this.customMatrix.Value); } else { sb.Begin(SpriteSortMode.Immediate, BlendState.Opaque, states.SamplerState, states.DepthStencilState, states.RasterizerState); } } }
/// <summary> /// Initializes a new instance of the <see cref="AdaptiveBinarizeForm"/> class. /// </summary> /// <param name="viewer">The image viewer for image preview.</param> /// <param name="rect">Selection rectangle.</param> /// <param name="blendColor">Blend color.</param> /// <param name="blendMode">Blending mode.</param> public ColorBlendForm(ImageViewer viewer, Rectangle rect, Color blendColor, BlendingMode blendMode) { InitializeComponent(); _imageProcessingPreviewInViewer = new ImageProcessingPreviewManager(viewer); _imageProcessingPreviewInViewer.UseCurrentViewerZoomWhenPreviewProcessing = true; _blendMode = blendMode; // set available blending modes Array values = Enum.GetValues(typeof(BlendingMode)); object[] vals = new object[values.Length]; values.CopyTo(vals, 0); blendModeComboBox.Items.AddRange(vals); blendModeComboBox.SelectedItem = blendMode; // set blend color channelAlphaTrackBar.Value = blendColor.A; channelRedTrackBar.Value = blendColor.R; channelGreenTrackBar.Value = blendColor.G; channelBlueTrackBar.Value = blendColor.B; _disableBlending = false; SetColor(); }
// Constructor public PresentLayer(RendererLayer layer, BlendingMode blending) { this.layer = layer; this.blending = blending; this.alpha = 1f; this.antialiasing = false; }
// Constructor public PresentLayer(RendererLayer layer) { this.layer = layer; this.blending = BlendingMode.None; this.alpha = 1f; this.antialiasing = false; }
public static int BlendingOperation(int pixel, int blend, BlendingMode mode) { double p = (double)pixel / 255; double b = (double)blend / 255; double result = -1; if (mode == BlendingMode.Multiply) { result = p * b; } else if (mode == BlendingMode.Overlay) { result = (p > 0.5 ? 1 : 0) * (1 - (1 - 2 * (p - 0.5)) * (1 - b)) + (p <= 0.5 ? 1 : 0) * ((2 * p) * b); } else if (mode == BlendingMode.Screen) { result = 1 - (1 - p) * (1 - b); } else if (mode == BlendingMode.LinearDodge) { result = p + b; } return((int)(result * 255)); }
// Constructor public PresentLayer(RendererLayer layer, BlendingMode blending, float alpha, bool antialiasing) { this.layer = layer; this.blending = blending; this.alpha = alpha; this.antialiasing = antialiasing; }
public void Reset() { colorMode = Consts.ColorModeDefault; color = Consts.FlatColor; colorFromLight = true; intensityFromLight = true; intensityModeAdvanced = false; intensityInside = Consts.IntensityDefault; intensityOutside = Consts.IntensityDefault; blendingMode = Consts.BlendingModeDefault; shaderAccuracy = Consts.ShaderAccuracyDefault; spotAngleFromLight = true; spotAngle = Consts.SpotAngleDefault; coneRadiusStart = Consts.ConeRadiusStart; geomMeshType = Consts.GeomMeshType; geomCustomSides = Consts.GeomSidesDefault; geomCustomSegments = Consts.GeomSegmentsDefault; geomCap = Consts.GeomCap; attenuationEquation = Consts.AttenuationEquationDefault; attenuationCustomBlending = Consts.AttenuationCustomBlending; fallOffEndFromLight = true; fallOffStart = Consts.FallOffStart; fallOffEnd = Consts.FallOffEnd; depthBlendDistance = Consts.DepthBlendDistance; cameraClippingDistance = Consts.CameraClippingDistance; glareFrontal = Consts.GlareFrontal; glareBehind = Consts.GlareBehind; fresnelPow = Consts.FresnelPow; noiseMode = Consts.NoiseModeDefault; noiseIntensity = Consts.NoiseIntensityDefault; noiseScaleUseGlobal = true; noiseScaleLocal = Consts.NoiseScaleDefault; noiseVelocityUseGlobal = true; noiseVelocityLocal = Consts.NoiseVelocityDefault; sortingLayerID = 0; sortingOrder = 0; fadeOutBegin = Consts.FadeOutBeginDefault; fadeOutEnd = Consts.FadeOutEndDefault; dimensions = Consts.DimensionsDefault; tiltFactor = Consts.TiltDefault; skewingLocalForwardDirection = Consts.SkewingLocalForwardDirectionDefault; clippingPlaneTransform = Consts.ClippingPlaneTransformDefault; trackChangesDuringPlaytime = false; m_EditorDirtyFlags = EditorDirtyFlags.Everything; }
public ModelMaterial(byte[] inData) { using (MemoryStream ms = new MemoryStream(inData)) { using (BinaryReader br = new BinaryReader(ms)) { this.Flags = (MaterialFlags)br.ReadUInt32(); this.Shader = (WMOFragmentShaderType)br.ReadUInt32(); this.BlendMode = (BlendingMode)br.ReadUInt32(); this.FirstTextureOffset = br.ReadUInt32(); this.FirstColour = br.ReadRGBA(); this.FirstFlags = (MaterialFlags)br.ReadUInt32(); this.SecondTextureOffset = br.ReadUInt32(); this.SecondColour = br.ReadRGBA(); this.GroundType = new ForeignKey <uint>(DatabaseName.TerrainType, nameof(DBCRecord.ID), br.ReadUInt32()); // TODO: Implement TerrainTypeRecord this.ThirdTextureOffset = br.ReadUInt32(); this.BaseDiffuseColour = br.ReadRGBA(); this.ThirdFlags = (MaterialFlags)br.ReadUInt32(); this.RuntimeData1 = br.ReadUInt32(); this.RuntimeData2 = br.ReadUInt32(); this.RuntimeData3 = br.ReadUInt32(); this.RuntimeData4 = br.ReadUInt32(); } } }
public ModelMaterial(byte[] inData) { using (MemoryStream ms = new MemoryStream(inData)) { using (BinaryReader br = new BinaryReader(ms)) { this.Flags = (MaterialFlags)br.ReadUInt32(); this.Shader = (ShaderTypes)br.ReadUInt32(); this.BlendMode = (BlendingMode)br.ReadUInt32(); this.FirstTextureOffset = br.ReadUInt32(); this.FirstColour = br.ReadRGBA(); this.FirstFlags = (MaterialFlags)br.ReadUInt32(); this.SecondTextureOffset = br.ReadUInt32(); this.SecondColour = br.ReadRGBA(); this.GroundType = new UInt32ForeignKey("TerrainType", "ID", br.ReadUInt32()); this.ThirdTextureOffset = br.ReadUInt32(); this.BaseDiffuseColour = br.ReadRGBA(); this.ThirdFlags = (MaterialFlags)br.ReadUInt32(); this.RuntimeData1 = br.ReadUInt32(); this.RuntimeData2 = br.ReadUInt32(); this.RuntimeData3 = br.ReadUInt32(); this.RuntimeData4 = br.ReadUInt32(); } } }
/// <summary> /// Function to initialize the sprite object. /// </summary> private void InitSprite() { // Convert the anchor to integer values and store separately. // We turn off anchoring for our display sprite so that we can edit the anchor // without doing all kinds of weird stuff to display the sprite correctly. _spriteAnchor = (Point)Sprite.Anchor; _blendMode = Sprite.BlendingMode; // Disable the sprite anchor. Sprite.Anchor = Vector2.Zero; Sprite.Scale = new Vector2(1); Sprite.Position = Vector2.Zero; TextureSprite = Renderer.Renderables.CreateSprite("TextureSprite", new Vector2(1), GorgonColor.Transparent); TextureSprite.TextureRegion = new RectangleF(0, 0, 1, 1); if (Sprite.Texture != null) { TextureSprite.Texture = Sprite.Texture; TextureSprite.Size = Sprite.Texture.Settings.Size; TextureSprite.Color = new GorgonColor(1, 1, 1, 0.35f); } _textureRect = Rectangle.Truncate(Sprite.Texture != null ? Sprite.Texture.ToPixel(Sprite.TextureRegion) : Sprite.TextureRegion); Vertices = new SpriteVertices(this); ValidateSpriteProperties(); }
static string InjectFragmentInstructions(string shader, BlendingMode blendingMode, string function) { var maskedComponent = blendingMode == BlendingMode.Classic ? ".a" : ""; return(ModifyFunctionReturn(shader, @"fixed4", function, (varName, inputName) => varName + maskedComponent + " *= SOFTMASK_GET_MASK(" + inputName + ");" )); }
public void BlendUsing(BlendingMode blendingMode) { RenderStates = new RenderStates( blendingMode.ToSfmlBlendMode(), RenderStates.Transform, RenderStates.Texture, RenderStates.Shader ); }
/// <summary> /// Handles the SelectedIndexChanged event of BlendingModeComboBox object. /// </summary> private void blendingModeComboBox_SelectedIndexChanged(object sender, EventArgs e) { if (_isFormInitializing) { return; } _blendingMode = (BlendingMode)blendingModeComboBox.SelectedItem; ExecuteProcessing(); }
internal static BlendMode ToSfmlBlendMode(this BlendingMode blendingMode) { return(blendingMode switch { BlendingMode.None => BlendMode.None, BlendingMode.Add => BlendMode.Add, BlendingMode.Alpha => BlendMode.Alpha, BlendingMode.Multiply => BlendMode.Multiply, _ => RenderStates.Default.BlendMode });
internal SpriteBase(BinaryReaderEx br, DRBVersion version) : base(br, version) { TexLeftEdge = br.ReadInt16(); TexTopEdge = br.ReadInt16(); TexRightEdge = br.ReadInt16(); TexBottomEdge = br.ReadInt16(); TextureIndex = br.ReadInt16(); Orientation = (SpriteOrientation)br.ReadByte(); BlendMode = br.ReadEnum8 <BlendingMode>(); }
/// <summary> /// Creates a simple <see cref="BlendState"/> with additive blending equation parameters. /// </summary> /// <param name="isOpaque">Whether this <see cref="BlendState"/> is opaque.</param> public BlendState(bool isOpaque) { IsOpaque = isOpaque; EquationModeRGB = BlendingMode.FuncAdd; EquationModeAlpha = BlendingMode.FuncAdd; SourceFactorRGB = BlendingFactor.One; SourceFactorAlpha = BlendingFactor.One; DestFactorRGB = BlendingFactor.One; DestFactorAlpha = BlendingFactor.One; }
//////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// public virtual void Begin(BlendingMode mode) { if (mode != BlendingMode.None) { sb.Begin(SpriteSortMode.Immediate, states.BlendState, states.SamplerState, states.DepthStencilState, states.RasterizerState); } else { sb.Begin(SpriteSortMode.Immediate, BlendState.Opaque, states.SamplerState, states.DepthStencilState, states.RasterizerState); } }
/// <summary> /// Initializes a new instance of the <see cref="MDXMaterial"/> class. /// </summary> /// <param name="br">The reader to read the instance from.</param> /// <param name="version">The version to read the instance in the context of.</param> public MDXMaterial(BinaryReader br, WarcraftVersion version) { Flags = (MDXRenderFlag)br.ReadUInt16(); if (version >= WarcraftVersion.Cataclysm) { BlendMode = (BlendingMode)br.ReadUInt16(); } else { BlendMode = RemapBlendingMode(br.ReadUInt16()); } }
/// <summary> /// Creates a <see cref="BlendState"/> with a simple color-blending equation. /// </summary> /// <param name="isOpaque">Whether this <see cref="BlendState"/> is opaque.</param> /// <param name="equationModeRgba">The equation mode to use for the RGBA values.</param> /// <param name="sourceFactorRgba">The source factor to use for the RGBA values.</param> /// <param name="destFactorRgba">The destination factor to use for the RGBA values.</param> /// <param name="blendColor">The equation-constant blending color.</param> public BlendState(bool isOpaque, BlendingMode equationModeRgba, BlendingFactor sourceFactorRgba, BlendingFactor destFactorRgba, Vector4 blendColor = default) { IsOpaque = isOpaque; EquationModeRGB = equationModeRgba; EquationModeAlpha = equationModeRgba; SourceFactorRGB = sourceFactorRgba; SourceFactorAlpha = sourceFactorRgba; DestFactorRGB = destFactorRgba; DestFactorAlpha = destFactorRgba; BlendColor = blendColor; }
// currentMonster.Name, Color.Red.ToHex(true)); // string.Format("You attempt to hit the [color:#FFFF0000]{0}[/color] but [color:{1}]MISS[/color]!", // example: /// BlendingMode.Default will begin drawing using the default blend state settings. /// </param> /// <param name="mode"> /// Specify BlendingMode.None will begin drawing in overwrite mode. /// <summary> /// Begins drawing batched objects. /// </summary> public virtual void Begin(BlendingMode mode) { bmode = mode; if (mode != BlendingMode.None) { sb.Begin(SpriteSortMode.Immediate, states.BlendState, states.SamplerState, states.DepthStencilState, states.RasterizerState); } // Grab the text color of the Enabled state. else { sb.Begin(SpriteSortMode.Immediate, BlendState.Opaque, states.SamplerState, states.DepthStencilState, states.RasterizerState); } }
public void Reset() { colorMode = Consts.ColorModeDefault; color = Consts.FlatColor; colorFromLight = true; alphaInside = Consts.Alpha; alphaOutside = Consts.Alpha; blendingMode = Consts.BlendingModeDefault; spotAngleFromLight = true; spotAngle = Consts.SpotAngleDefault; coneRadiusStart = Consts.ConeRadiusStart; geomMeshType = Consts.GeomMeshType; geomCustomSides = Consts.GeomSidesDefault; geomCustomSegments = Consts.GeomSegmentsDefault; geomCap = Consts.GeomCap; attenuationEquation = Consts.AttenuationEquationDefault; attenuationCustomBlending = Consts.AttenuationCustomBlending; fadeEndFromLight = true; fadeStart = Consts.FadeStart; fadeEnd = Consts.FadeEnd; depthBlendDistance = Consts.DepthBlendDistance; cameraClippingDistance = Consts.CameraClippingDistance; glareFrontal = Consts.GlareFrontal; glareBehind = Consts.GlareBehind; fresnelPow = Consts.FresnelPow; noiseEnabled = false; noiseIntensity = Consts.NoiseIntensityDefault; noiseScaleUseGlobal = true; noiseScaleLocal = Consts.NoiseScaleDefault; noiseVelocityUseGlobal = true; noiseVelocityLocal = Consts.NoiseVelocityDefault; sortingLayerID = 0; sortingOrder = 0; trackChangesDuringPlaytime = false; m_EditorDirtyFlags = EditorDirtyFlags.Everything; }
public static BlendMode toBlendMode(this BlendingMode B) { switch (B) { case BlendingMode.None: return(BlendMode.None); case BlendingMode.Alpha: return(BlendMode.Alpha); case BlendingMode.Add: return(BlendMode.Add); case BlendingMode.Multiply: return(BlendMode.Multiply); } return(BlendMode.None); }
public static Color GetBlendingFactor( BlendingMode blend, Color s, Color d) { Color factor = new Color(1,1,1,1); switch (blend) { case BlendingMode.Color: factor = Color.white; break; case BlendingMode.Mask: factor = factor - new Color( s.a, s.a, s.a, s.a); break; case BlendingMode.Alpha: factor = new Color( s.a, s.a, s.a, s.a); break; } return factor; }
public BlendingFactorState(BlendingMode mode) { switch (mode) { case BlendingMode.Off: enabled = false; break; case BlendingMode.Alphablend: src = alphaSrc = BlendingFactorSrc.SrcAlpha; dest = alphaDest = BlendingFactorDest.OneMinusSrcAlpha; break; case BlendingMode.Color: src = BlendingFactorSrc.SrcAlpha; dest = BlendingFactorDest.OneMinusSrcAlpha; alphaSrc = BlendingFactorSrc.Zero; alphaDest = BlendingFactorDest.One; break; case BlendingMode.Additive: src = alphaSrc = BlendingFactorSrc.SrcAlpha; dest = alphaDest = BlendingFactorDest.One; break; case BlendingMode.Premultiply: src = BlendingFactorSrc.SrcAlpha; dest = BlendingFactorDest.OneMinusSrcAlpha; alphaSrc = BlendingFactorSrc.One; alphaDest = BlendingFactorDest.OneMinusSrcAlpha; break; case BlendingMode.Premultiplied: src = alphaSrc = BlendingFactorSrc.One; dest = alphaDest = BlendingFactorDest.OneMinusSrcAlpha; break; } }
/// <summary> /// Executes the ColorBlendCommand command. /// </summary> public void ExecuteColorBlendCommand() { ColorBlendForm dlg; try { dlg = new ColorBlendForm(_viewer, ViewerSelectionRectangle, _blendColor, _blendMode); } catch (ImageProcessingException ex) { MessageBox.Show(ex.Message, "Image processing exception", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); return; } if (dlg.ShowProcessingDialog()) { _blendMode = dlg.BlendMode; _blendColor = dlg.BlendColor; ColorBlendCommand command = ImageProcessingCommandFactory.CreateColorBlendCommand(_viewer.Image); command.BlendingMode = _blendMode; command.BlendColor = _blendColor; ExecuteProcessingCommand(command); } }
static extern void EntityParameters_SetBlendingMode(IntPtr pointer, BlendingMode value);
public void RenderBSPBackToFront(BlendingMode currentTransparency, BSPNode root, UnlitTintedShaderDescription shader) { var d = root.Plane.Distance(EngineCamera.Position); if (d >= 0) { if (root.Back != null) { RenderBSPBackToFront(currentTransparency, root.Back, shader); } foreach (var p in root.PolygonsBack) { RenderPolygonTransparency(currentTransparency, p, shader); } foreach (var p in root.PolygonsFront) { RenderPolygonTransparency(currentTransparency, p, shader); } if (root.Front != null) { RenderBSPBackToFront(currentTransparency, root.Front, shader); } } else { if (root.Front != null) { RenderBSPBackToFront(currentTransparency, root.Front, shader); } foreach (var p in root.PolygonsFront) { RenderPolygonTransparency(currentTransparency, p, shader); } foreach (var p in root.PolygonsBack) { RenderPolygonTransparency(currentTransparency, p, shader); } if (root.Back != null) { RenderBSPBackToFront(currentTransparency, root.Back, shader); } } }
public void RenderPolygonTransparency(BlendingMode currentTransparency, BSPFaceRef bspRef, UnlitTintedShaderDescription shader) { // Blending mode switcher. // Note that modes above 2 aren't explicitly used in TR textures, only for // internal particle processing. Theoretically it's still possible to use // them if you will force type via TRTextur utility. var refe = bspRef.Polygon; var p = refe.Polygon; if(currentTransparency != p.BlendMode) { currentTransparency = p.BlendMode; switch (p.BlendMode) { case BlendingMode.Multiply: // Classic PC alpha GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.One); break; case BlendingMode.InvertSrc: // Inversion by src (PS darkness) - SAME AS IN TR3-TR5 GL.BlendFunc(BlendingFactorSrc.Zero, BlendingFactorDest.OneMinusSrcAlpha); break; case BlendingMode.InvertDst: // Inversion by dest GL.BlendFunc(BlendingFactorSrc.OneMinusSrcColor, BlendingFactorDest.OneMinusSrcAlpha); break; case BlendingMode.Screen: // Screen (smoke, etc.) GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.OneMinusSrcAlpha); break; case BlendingMode.AnimatedTexture: GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.Zero); break; } } var mvp = Camera.GLViewProjMat.MultiplyByTransform(bspRef.Transform); GL.UniformMatrix4(shader.ModelViewProjection, false, ref mvp); refe.UsedVertexArray.Bind(); GL.BindTexture(TextureTarget.Texture2D, World.Textures[p.TexIndex]); GL.DrawElements(PrimitiveType.Triangles, (int)refe.Count, DrawElementsType.UnsignedInt, (int)(sizeof(uint) * refe.FirstIndex)); }
public static void SetBlendingMode(this GraphicsDevice _, BlendingMode blendingMode) { GraphicsDeviceExtensions.blendCombiner.BlendingMode = blendingMode; }
public void BlendFunc(BlendingMode sfactor, BlendingMode dfactor) => this.CallMethod <object>(BLEND_FUNC, sfactor, dfactor);
public void BlendFuncSeparate(BlendingMode srcRGB, BlendingMode dstRGB, BlendingMode srcAlpha, BlendingMode dstAlpha) => this.CallMethod <object>(BLEND_FUNC_SEPARATE, srcRGB, dstRGB, srcAlpha, dstAlpha);
public ModelMaterial(byte[] inData) { using (MemoryStream ms = new MemoryStream(inData)) { using (BinaryReader br = new BinaryReader(ms)) { this.Flags = (MaterialFlags) br.ReadUInt32(); this.Shader = (ShaderTypes) br.ReadUInt32(); this.BlendMode = (BlendingMode) br.ReadUInt32(); this.FirstTextureOffset = br.ReadUInt32(); this.FirstColour = br.ReadRGBA(); this.FirstFlags = (MaterialFlags)br.ReadUInt32(); this.SecondTextureOffset = br.ReadUInt32(); this.SecondColour = br.ReadRGBA(); this.GroundType = new UInt32ForeignKey("TerrainType", "ID", br.ReadUInt32()); this.ThirdTextureOffset = br.ReadUInt32(); this.BaseDiffuseColour = br.ReadRGBA(); this.ThirdFlags = (MaterialFlags)br.ReadUInt32(); this.RuntimeData1 = br.ReadUInt32(); this.RuntimeData2 = br.ReadUInt32(); this.RuntimeData3 = br.ReadUInt32(); this.RuntimeData4 = br.ReadUInt32(); } } }
//property.Expanded = EditorGUILayout.Foldout( property.Expanded, property.GetPropertyType().PropertyTypeString() ); public void Draw() { var shaderNameContent = new GUIContent( "Shader Name", "Name for shader. Includes the hierarchy listing, that is, MyShaders/Shader will be in a folder called \"MyShaders\" in the shader selection dropdown. Also used when referring to fallback shaders."); var oldColor = GUI.color; if( string.IsNullOrEmpty(_shaderName ) ) { GUI.color = Color.red; } _shaderName.Value = EditorGUILayout.TextField(shaderNameContent, _shaderName.Value); GUI.color = oldColor; var shaderFallbackContent = new GUIContent( "Shader Fallback", "Fallback shader to use in case this shader can not be used."); _shaderFallback.Value = EditorGUILayout.TextField( shaderFallbackContent, _shaderFallback.Value ); var targetContent = new GUIContent("Shader Model","Requires more recent hardware to use the shader, but allows for more instructions, texture reads, and more input information."); _shaderTarget = (ShaderTarget)EditorGUILayout.EnumPopup( targetContent, _shaderTarget ); var excludePathContent = new GUIContent("Exclude Path","Exclude a renderpath from shader generation"); _excludePath = (ExcludePath)EditorGUILayout.EnumPopup( excludePathContent, _excludePath ); GUILayout.Space(8); _showQueueSettings = EditorGUILayout.Foldout( _showQueueSettings, "Queue Settings" ); if( _showQueueSettings ) { var renderTypeContent = new GUIContent("Render Type","This is the rendertype tag inserted into the shader. Can be used for shader replace"); _renderType = (RenderType)EditorGUILayout.EnumPopup( renderTypeContent, _renderType ); if ( _renderType == RenderType.Custom ) _renderTypeCustom.Value = EditorGUILayout.TextField( "Custom Type" ,_renderTypeCustom.Value ); var queueContent = new GUIContent("Render Queue","The render queue that this material will be put in"); _queue = (Queue)EditorGUILayout.EnumPopup( queueContent, _queue ); var offContent = new GUIContent( "Queue Offset", "Offset for drawing. Used to ensure some things draw before or after others, it specifically is an offset from the given queue- That is to say, you won't have a transparent object draw before an opaque object (or similar) due to this offset."); _queueAdjust = EditorGUILayout.IntSlider(offContent, _queueAdjust.Value, -100, 100); } GUILayout.Space( 8 ); _showCullingAndDepthSettings = EditorGUILayout.Foldout( _showCullingAndDepthSettings, "Culling and Depth Settings" ); if( _showCullingAndDepthSettings ) { var zWriteContent = new GUIContent("Write Depth","Depth is considered when testing other objects. Disable for certain effects, like letting other things draw over yourself, or for speed on most overlays."); _zWrite = (ZWrite)EditorGUILayout.EnumPopup( zWriteContent, _zWrite ); var cullModeContent = new GUIContent("CullMode","Select back / forward to clip backwards facing polygons"); _cullMode = (CullMode)EditorGUILayout.EnumPopup( cullModeContent, _cullMode ); var zTestContent = new GUIContent("ZTest","Select Z-Test Value"); _zTest = (ZTest)EditorGUILayout.EnumPopup( zTestContent, _zTest ); var enableLODContent = new GUIContent("Enable LOD","Enable Shader LOD scaling"); _enableLOD = EditorGUILayout.BeginToggleGroup( enableLODContent, _enableLOD ); _lod = EditorGUILayout.IntSlider( "LOD", _lod, 0, 1000 ); EditorGUILayout.EndToggleGroup(); } GUILayout.Space( 8 ); _showBlending = EditorGUILayout.Foldout( _showBlending, "Blending Settings" ); if( _showBlending ) { var blendingTypeContent = new GUIContent("Blend Type","Use a build in blend mode or a custom blend mode"); _blending = (BlendingType)EditorGUILayout.EnumPopup( blendingTypeContent, _blending ); if( CustomBlendingEnabled() ) { var srcBlendContent = new GUIContent("Src Blend Mode","How the source channel of blending is used"); _srcBlend = (BlendingMode)EditorGUILayout.EnumPopup( srcBlendContent, _srcBlend ); var dstBlendContent = new GUIContent("Dst Blend Mode","How the destination channel of blending is used"); _dstBlend = (BlendingMode)EditorGUILayout.EnumPopup( dstBlendContent, _dstBlend ); } } GUILayout.Space( 8 ); _showColorAndLighting = EditorGUILayout.Foldout( _showColorAndLighting, "Color And Lighting Settings" ); if( _showColorAndLighting ) { GUILayout.BeginHorizontal(); GUILayout.Label( "Color Mask:", GUILayout.ExpandWidth(false) ); _colorMaskR.Value = EditorExtensions.ToggleButton( _colorMaskR.Value, "R","Mask R Channel"); _colorMaskG.Value = EditorExtensions.ToggleButton( _colorMaskG.Value, "G","Mask G Channel"); _colorMaskB.Value = EditorExtensions.ToggleButton( _colorMaskB.Value, "B","Mask B Channel"); _colorMaskA.Value = EditorExtensions.ToggleButton( _colorMaskA.Value, "A","Mask A Channel"); GUILayout.EndHorizontal(); _dualForward = GUILayout.Toggle( _dualForward, new GUIContent( "Forward Dual Lightmaps","Use dual lightmaps in the forward rendering path" )); _fullForwardShadows = GUILayout.Toggle( _fullForwardShadows, new GUIContent( "Forward Full Shadows", "Support all shadow types in Forward rendering path." )); _softVegetation = GUILayout.Toggle( _softVegetation, new GUIContent( "Soft Vegetation", "Makes the surface shader only be rendered when Soft Vegetation is on." )); _noAmbient = GUILayout.Toggle( _noAmbient, new GUIContent( "No Ambient", "Do not apply any ambient lighting or spherical harmonics lights.")); _noLightmap = GUILayout.Toggle( _noLightmap, new GUIContent( "No Lightmaps", "Disables lightmap support in this shader (makes a shader smaller)." )); _addShadow = GUILayout.Toggle( _addShadow, new GUIContent( "Advanced Shadow Pass", "Performs vertex transformations and clipping for the shadow pass, you need to use this if shadows do not display properly." )); _ignoreProjectors = GUILayout.Toggle( _ignoreProjectors, new GUIContent( "Ignore Projectors", "Ignores projector components, should be used if your doing custom vertex transformations or most transparency" )); _approxview = GUILayout.Toggle( _approxview, new GUIContent( "Approximate View", "Computes normalized view direction per-vertex instead of per-pixel, for shaders that need it. This is faster, but view direction is not entirely correct when camera gets close to surface." )); _halfasview = GUILayout.Toggle( _halfasview, new GUIContent( "Half As View", "Pass half-direction vector into the lighting function instead of view-direction. Half-direction will be computed and normalized per vertex. This is faster, but not entirely correct." )); _noForwardAdd = GUILayout.Toggle( _noForwardAdd, new GUIContent( "Disable Forward Add", "Disables Forward rendering additive pass. This makes the shader support one full directional light, with all other lights computed per-vertex/SH. Makes shaders smaller as well." )); } GUILayout.Space( 8 ); _showFogSettings = EditorGUILayout.Foldout( _showFogSettings, "Fog Settings" ); if( _showFogSettings ) { _fogModeOverride = EditorGUILayout.BeginToggleGroup( "Fog Mode Override", _fogModeOverride ); var fogModeContent = new GUIContent("Fog Mode","The type of fog to use"); _fogMode = (FogMode)EditorGUILayout.EnumPopup( fogModeContent, _fogMode ); if( _fogMode == FogMode.Linear ) { _fogNearLinear.Value = EditorGUILayout.FloatField( "Near Linear Range:", _fogNearLinear ); _fogFarLinear.Value = EditorGUILayout.FloatField( "Far Linear Range:", _fogFarLinear ); } EditorGUILayout.EndToggleGroup(); _fogColorOverride = EditorGUILayout.BeginToggleGroup( "Fog Color Override", _fogColorOverride ); _fogColor.Value = EditorGUILayout.ColorField("Fog Color:", _fogColor ); EditorGUILayout.EndToggleGroup(); _fogDensityOverride = EditorGUILayout.BeginToggleGroup( "Fog Density Override", _fogDensityOverride ); _fogDensity.Value = EditorGUILayout.FloatField( "Fog Density:", _fogDensity ); EditorGUILayout.EndToggleGroup(); } }
public void SetBlendingMode(BlendingMode mode = BlendingMode.Opaque) { blendingMode = mode; }
/// <summary> /// Adjusts <see cref="Drawable.Blending"/> after a delay. /// </summary> /// <returns>A <see cref="TransformSequence{T}"/> to which further transforms can be added.</returns> public static TransformSequence <T> TransformBlendingMode <T>(this T drawable, BlendingMode newValue, double delay = 0) where T : Drawable => drawable.TransformTo(drawable.PopulateTransform(new TransformBlendingMode(), newValue, delay));
public void CreateWMOObject() { if (terrainHandler.working) { WMO.WMOStruct data = WMO.AllWMOData.Dequeue(); GameObject WMOinstance = new GameObject(); terrainHandler.LoadedWMOIds[data.fileDataId] = WMOinstance; int nGroups = data.Info.nGroups; for (int g = 0; g < nGroups; g++) { // group object // GameObject GroupInstance = new GameObject(); GroupInstance.isStatic = true; GroupInstance.transform.SetParent(terrainHandler.LoadedWMOIds[data.fileDataId].transform); GroupInstance.name = data.groupsData[g].groupName; LODGroup Lodgroup = GroupInstance.AddComponent <LODGroup>(); LOD[] lods = new LOD[1]; Renderer[] renderers = new Renderer[data.groupsData[g].nBatches]; // Batches // for (int bn = 0; bn < data.groupsData[g].nBatches; bn++) { //////////////////////////////// #region object GameObject BatchInstance = new GameObject(); BatchInstance.isStatic = true; BatchInstance.transform.SetParent(GroupInstance.transform); BatchInstance.name = bn.ToString(); BatchInstance.transform.transform.eulerAngles = new Vector3(BatchInstance.transform.transform.eulerAngles.x, BatchInstance.transform.transform.eulerAngles.y - 180, GroupInstance.transform.transform.eulerAngles.z); #endregion //////////////////////////////// //////////////////////////////// #region mesh BatchInstance.AddComponent <MeshRenderer>(); BatchInstance.GetComponent <MeshRenderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided; renderers[bn] = BatchInstance.GetComponent <MeshRenderer>(); BatchInstance.AddComponent <MeshFilter>(); Mesh bmesh = new Mesh(); uint batchVertSize = data.groupsData[g].batch_MaxIndex[bn] - data.groupsData[g].batch_MinIndex[bn] + 1; Vector3[] batchVertices = new Vector3[batchVertSize]; Vector2[] batchUVs = new Vector2[batchVertSize]; Vector3[] batchNormals = new Vector3[batchVertSize]; Color32[] batchVertexColors = new Color32[batchVertSize]; List <int> batchTrianglesList = new List <int>(); int[] batchTriangles; int arrayPosition = 0; uint batch_startVertex = data.groupsData[g].batch_MinIndex[bn]; uint batch_endVertex = data.groupsData[g].batch_MaxIndex[bn]; for (uint v = batch_startVertex; v <= batch_endVertex; v++) { batchVertices[arrayPosition] = data.groupsData[g].vertices[v]; batchUVs[arrayPosition] = data.groupsData[g].UVs[v]; batchNormals[arrayPosition] = data.groupsData[g].normals[v]; if (!data.groupsData[g].flags.Hasvertexolors) { batchVertexColors[arrayPosition] = new Color32(127, 127, 127, 127); } else { batchVertexColors[arrayPosition] = data.groupsData[g].vertexColors[(int)v]; } arrayPosition++; } uint batch_startIndex = data.groupsData[g].batch_StartIndex[bn]; uint batch_nIndices = data.groupsData[g].batch_Count[bn]; for (uint idx = batch_startIndex; idx <= batch_startIndex + batch_nIndices - 2; idx = idx + 3) { uint in1 = data.groupsData[g].triangles[idx + 0]; uint in2 = data.groupsData[g].triangles[idx + 1]; uint in3 = data.groupsData[g].triangles[idx + 2]; int a = (int)(in1 - batch_startVertex); int b = (int)(in2 - batch_startVertex); int c = (int)(in3 - batch_startVertex); batchTrianglesList.Add(a); batchTrianglesList.Add(b); batchTrianglesList.Add(c); } batchTrianglesList.Reverse(); batchTriangles = batchTrianglesList.ToArray(); bmesh.vertices = batchVertices; bmesh.uv = batchUVs; bmesh.normals = batchNormals; bmesh.triangles = batchTriangles; bmesh.colors32 = batchVertexColors; BatchInstance.GetComponent <MeshFilter>().mesh = bmesh; BatchInstance.GetComponent <MeshRenderer>().sharedMaterial = missingMaterial; #endregion //////////////////////////////// //////////////////////////////// #region material uint TextureFileDataId = data.texturePaths[data.materials[data.groupsData[g].batchMaterialIDs[bn]].TextureId1]; BatchInstance.GetComponent <Renderer>().material = WMOmaterials[(int)data.materials[data.groupsData[g].batchMaterialIDs[bn]].ShaderType]; //////////////////////////////// #region Set Fragment Shader WMOFragmentShader shader = data.materials[data.groupsData[g].batchMaterialIDs[bn]].ShaderType; switch (shader) { case WMOFragmentShader.Diffuse: { BatchInstance.GetComponent <Renderer>().material.SetFloat("_ShaderDiffuse", 1.0f); break; } case WMOFragmentShader.Specular: { BatchInstance.GetComponent <Renderer>().material.SetFloat("_ShaderSpecular", 1.0f); break; } case WMOFragmentShader.Metal: { BatchInstance.GetComponent <Renderer>().material.SetFloat("_ShaderMetal", 1.0f); break; } case WMOFragmentShader.Env: { BatchInstance.GetComponent <Renderer>().material.SetFloat("_ShaderEnv", 1.0f); break; } case WMOFragmentShader.Opaque: { BatchInstance.GetComponent <Renderer>().material.SetFloat("_ShaderOpaque", 1.0f); BatchInstance.GetComponent <Renderer>().material.SetFloat("_AlphaToMask", 1.0f); break; } default: { BatchInstance.GetComponent <Renderer>().material.SetFloat("_ShaderDiffuse", 1.0f); break; } } #endregion //////////////////////////////// //////////////////////////////// #region Set Material Flags // F_UNCULLED // int Culling = 2; // on (only front) if (data.materials[data.groupsData[g].batchMaterialIDs[bn]].flags.F_UNCULLED) { Culling = 0; // off (both sides_ } BatchInstance.GetComponent <Renderer>().material.SetFloat("F_UNCULLED", Culling); // F_UNLIT // if (data.materials[data.groupsData[g].batchMaterialIDs[bn]].flags.F_UNLIT) { BatchInstance.GetComponent <Renderer>().material.EnableKeyword("F_UNLIT"); } //BatchInstance.GetComponent<Renderer>().material.SetFloat("_F_UNLIT", data.materials[data.groupsData[g].batchMaterialIDs[bn]].flags.F_UNLIT ? 1 : 0); // F_UNFOGGED // BatchInstance.GetComponent <Renderer>().material.SetFloat("_F_UNFOGGED", data.materials[data.groupsData[g].batchMaterialIDs[bn]].flags.F_UNFOGGED ? 1 : 0); #endregion //////////////////////////////// //////////////////////////////// #region Set Blending Mode // set default blend: One Zero, basicly off UnityEngine.Rendering.BlendMode source = UnityEngine.Rendering.BlendMode.One; UnityEngine.Rendering.BlendMode destination = UnityEngine.Rendering.BlendMode.Zero; BlendingMode blending = data.materials[data.groupsData[g].batchMaterialIDs[bn]].BlendMode; switch (blending) { case BlendingMode.Opaque: { source = UnityEngine.Rendering.BlendMode.One; destination = UnityEngine.Rendering.BlendMode.Zero; break; } case BlendingMode.AlphaKey: { source = UnityEngine.Rendering.BlendMode.One; destination = UnityEngine.Rendering.BlendMode.Zero; break; } case BlendingMode.Alpha: { source = UnityEngine.Rendering.BlendMode.SrcAlpha; destination = UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha; break; } case BlendingMode.Additive: { source = UnityEngine.Rendering.BlendMode.One; destination = UnityEngine.Rendering.BlendMode.One; break; } case BlendingMode.Modulate: { source = UnityEngine.Rendering.BlendMode.DstColor; destination = UnityEngine.Rendering.BlendMode.Zero; break; } case BlendingMode.Modulate2x: { source = UnityEngine.Rendering.BlendMode.DstColor; destination = UnityEngine.Rendering.BlendMode.SrcColor; break; } case BlendingMode.ModulateAdditive: { source = UnityEngine.Rendering.BlendMode.DstColor; destination = UnityEngine.Rendering.BlendMode.One; break; } default: { Debug.Log("BlendMode To Add: " + blending.ToString() + " Texture Used: " + TextureFileDataId); source = UnityEngine.Rendering.BlendMode.One; destination = UnityEngine.Rendering.BlendMode.Zero; break; } } BatchInstance.GetComponent <Renderer>().material.SetInt("MySrcMode", (int)source); BatchInstance.GetComponent <Renderer>().material.SetInt("MyDstMode", (int)destination); #endregion //////////////////////////////// //////////////////////////////// #region Assign Textures if (LoadedWMOTextures.ContainsKey(TextureFileDataId)) { BatchInstance.GetComponent <Renderer>().material.SetTexture("_MainTex", LoadedWMOTextures[TextureFileDataId]); } else { try { Texture2Ddata tdata = data.textureData[TextureFileDataId]; Texture2D tex = new Texture2D(tdata.width, tdata.height, tdata.textureFormat, tdata.hasMipmaps); tex.LoadRawTextureData(tdata.TextureData); tex.Apply(); LoadedWMOTextures[TextureFileDataId] = tex; BatchInstance.GetComponent <Renderer>().material.SetTexture("_MainTex", tex); } catch (Exception ex) { Debug.Log("Error: Loading RawTextureData @ WMOhandler"); Debug.LogException(ex); } } #endregion //////////////////////////////// #endregion //////////////////////////////// } lods[0] = new LOD(.1f, renderers); Lodgroup.SetLODs(lods); Lodgroup.animateCrossFading = true; Lodgroup.fadeMode = LODFadeMode.SpeedTree; Lodgroup.RecalculateBounds(); } terrainHandler.LoadedWMOIds[data.fileDataId].transform.position = data.position; terrainHandler.LoadedWMOIds[data.fileDataId].transform.rotation = data.rotation; terrainHandler.LoadedWMOIds[data.fileDataId].transform.localScale = data.scale; if (data.uniqueID != -1) { if (terrainHandler.ADTBlockWMOParents[data.uniqueID] != null) { terrainHandler.LoadedWMOIds[data.fileDataId].transform.SetParent(terrainHandler.ADTBlockWMOParents[data.uniqueID].transform); } else { Destroy(terrainHandler.LoadedWMOIds[data.fileDataId]); } } terrainHandler.LoadedWMOIds[data.fileDataId].name = data.Info.wmoID.ToString(); terrainHandler.frameBusy = false; } }