//CLIPPING
private void comboBox5_SelectedIndexChanged(object sender, EventArgs e)
{
switch (comboBox5.SelectedIndex)
{
case 0:
clipping = 0;
break;
case 1:
clipping = Clipping.ZBuffer;
break;
case 2:
clipping = Clipping.Gouraud;
break;
case 3:
clipping = Clipping.Texture;
break;
default:
clipping = 0;
break;
}
}
public void GetHashCode_ReturnsSameHashCodeForIdenticalClippings(Clipping dummyClipping1,
Clipping dummyClipping2,
bool identical)
{
// Act and assert
Assert.Equal(identical, dummyClipping1.GetHashCode() == dummyClipping2.GetHashCode());
}
public void TestOtherCharsNotDigitOrHyphenDetected()
{
char c = (char)'r';
bool isDigitOrHyphen = Clipping.CharIsDigitOrHyphen(c);
Assert.AreEqual(false, isDigitOrHyphen);
}
public void TestCharIsDigitOrHyphenReturnsTrueForDigits()
{
char c = (char)'1';
bool isDigit = Clipping.CharIsDigitOrHyphen(c);
Assert.IsTrue(isDigit);
}
protected override void UpdateCache(Context ctx)
{
Rectangle rb = Slot + Parent.ClientRectangle.Position;
Context gr = new Context(bmp);
if (!Clipping.IsEmpty)
{
for (int i = 0; i < Clipping.NumRectangles; i++)
{
gr.Rectangle(Clipping.GetRectangle(i));
}
gr.ClipPreserve();
gr.Operator = Operator.Clear;
gr.Fill();
gr.Operator = Operator.Over;
onDraw(gr);
}
gr.Dispose();
ctx.SetSourceSurface(bmp, rb.X, rb.Y);
ctx.Paint();
Clipping.Dispose();
Clipping = new Region();
}
public void IsNullOrEmptyDetectsNullClippings()
{
Clipping myNullClipping = null;
bool isNull = Clipping.IsNullOrEmpty(myNullClipping);
Assert.IsTrue(isNull);
}
private void DibujarTerreno(Terreno terreno, Boolean aplicarClipping, ViewPort viewPort)
{
foreach (Poligono poligono in PoligonosTerreno)
{
IList puntosDibujo;
if (aplicarClipping)
{
puntosDibujo = Clipping.RecortarPoligono(poligono.Puntos, viewPort);
}
else
{
puntosDibujo = poligono.Puntos;
}
// Se rellena el polígono
//Pintar.RellenarPoligonoScanLine(puntosDibujo, poligono.ColorRelleno);
Gl.glColor3f(poligono.ColorLinea.Red, poligono.ColorLinea.Green, poligono.ColorLinea.Blue);
// Todos los puntos van a ser unidos por segmentos y el último se une al primero
Gl.glBegin(Gl.GL_POLYGON);
foreach (Punto punto in puntosDibujo)
{
Gl.glVertex2d(punto.GetXFlotante(), punto.GetYFlotante());
}
Gl.glEnd();
}
}
public void TestCharIsDigitOrHyphenReturnsTrueForHyphens()
{
char c = (char)'-';
bool isHyphen = Clipping.CharIsDigitOrHyphen(c);
Assert.IsTrue(isHyphen);
}
public void TestIsBookmark()
{
clipping.ClippingType = ClippingTypeEnum.Bookmark;
bool isBk = Clipping.IsBookMark(clipping);
Assert.IsTrue(isBk);
}
/// <summary>
/// Adds a clipping to the database and returns a unique identifier for later retrieval
/// </summary>
/// <param name="clipping">The clipping to add to the database</param>
/// <returns>The unique identifier corresponding to this clipping</returns>
public static int AddClipping(Clipping clipping)
{
var id = _clippings.Keys.Count;
_clippings.Add(id, clipping);
return(id);
}
public static IEnumerable <object[]> FlexiIncludeBlockOptions_CanBePopulated_Data()
{
const string dummySource = "dummySource";
const FlexiIncludeType dummyType = FlexiIncludeType.Markdown;
const bool dummyCache = false;
const string dummyCacheDirectory = "dummyCacheDirectory";
var dummyClipping1 = new Clipping(10, 15);
var dummyClippings1 = new List <Clipping> {
dummyClipping1
};
var dummyClipping2 = new Clipping(2, 21);
var dummyClippings2 = new List <Clipping> {
dummyClipping2
};
return(new object[][]
{
// Populating FlexiIncludeBlockOptions containing default values
new object[]
{
new SerializableWrapper <FlexiIncludeBlockOptions>(new FlexiIncludeBlockOptions()),
new SerializableWrapper <FlexiIncludeBlockOptions>(new FlexiIncludeBlockOptions(dummySource,
dummyClippings1,
dummyType,
dummyCache,
dummyCacheDirectory)),
$@"{{
""{nameof(FlexiIncludeBlockOptions.Source)}"": ""{dummySource}"",
""{nameof(FlexiIncludeBlockOptions.Type)}"": ""{dummyType}"",
""{nameof(FlexiIncludeBlockOptions.Cache)}"": ""{dummyCache}"",
""{nameof(FlexiIncludeBlockOptions.CacheDirectory)}"": ""{dummyCacheDirectory}"",
""{nameof(FlexiIncludeBlockOptions.Clippings)}"": [
{{
""{nameof(Clipping.StartLine)}"": ""{dummyClipping1.StartLine}"",
""{nameof(Clipping.EndLine)}"": ""{dummyClipping1.EndLine}""
}}
]
}}"
},
// Populating FlexiIncludeBlockOptions with an existing clippings collection (should be replaced instead of appended to)
new object[]
{
new SerializableWrapper <FlexiIncludeBlockOptions>(new FlexiIncludeBlockOptions(clippings: dummyClippings1)),
new SerializableWrapper <FlexiIncludeBlockOptions>(new FlexiIncludeBlockOptions(clippings: dummyClippings2)),
$@"{{
""{nameof(FlexiIncludeBlockOptions.Clippings)}"": [
{{
""{nameof(Clipping.StartLine)}"": ""{dummyClipping2.StartLine}"",
""{nameof(Clipping.EndLine)}"": ""{dummyClipping2.EndLine}""
}}
]
}}"
}
});
}
public ClippingParserTests()
{
this.stream = new MemoryStream();
this.writer = new StreamWriter(this.stream, Encoding.Unicode)
{
AutoFlush = true
};
this.clipping = new Clipping();
}
/// <summary>
/// Constructor
/// </summary>
public ShapeParser(CssStyleCascade cssStyleCascade,
BrushParser brushParser,
GeometryParser geometryParser,
Clipping clipping)
{
this.cssStyleCascade = cssStyleCascade;
this.brushParser = brushParser;
this.geometryParser = geometryParser;
this.clipping = clipping;
}
/// <summary>
/// Perform rendering.
/// </summary>
/// <param name="context">Rendering context.</param>
public override void Render(RenderContext context)
{
Rectangle clipRect = ClientRectangle;
clipRect.Height++;
// Limit drawing to our client area
using (Clipping clip = new Clipping(context.Graphics, clipRect))
base.Render(context);
}
public ActionResult <IEnumerable <Clipping> > Post()
{
var clippings = new Collection <Clipping>();
if (Request.Body.CanRead)
{
using (var sr = new StreamReader(Request.Body, Encoding.UTF8))
{
int lineNumber = 0;
string line = null;
int clippingLineNumber = 0;
Clipping clipping = new Clipping();
try
{
while ((line = sr.ReadLine()) != null)
{
lineNumber++;
if (line == ClippingSeparator)
{
clippings.Add(clipping);
clippingLineNumber = 0;
clipping = new Clipping();
}
else
{
clippingLineNumber++;
}
switch (clippingLineNumber)
{
case 1:
ParseLine1(line, clipping);
break;
case 2:
ParseLine2(line, clipping);
break;
case 4:
ParseLine4(line, clipping);
break;
}
}
}
catch (Exception ex)
{
throw new Exception("Error encountered parsing line " + lineNumber + ": " + ex.Message, ex);
}
}
}
return(clippings);
}
protected override void UpdateCache(Context ctx)
{
Rectangle rb = Slot + Parent.ClientRectangle.Position;
Context gr = new Context(bmp);
if (!Clipping.IsEmpty)
{
for (int i = 0; i < Clipping.NumRectangles; i++)
{
gr.Rectangle(Clipping.GetRectangle(i));
}
gr.ClipPreserve();
gr.Operator = Operator.Clear;
gr.Fill();
gr.Operator = Operator.Over;
base.onDraw(gr);
if (ClipToClientRect)
{
CairoHelpers.CairoRectangle(gr, ClientRectangle, CornerRadius);
gr.Clip();
}
childrenRWLock.EnterReadLock();
foreach (GraphicObject c in Children)
{
if (!c.Visible)
{
continue;
}
if (Clipping.Contains(c.Slot + ClientRectangle.Position) == RegionOverlap.Out)
{
continue;
}
c.Paint(ref gr);
}
childrenRWLock.ExitReadLock();
#if DEBUG_CLIP_RECTANGLE
Clipping.stroke(gr, Color.Amaranth.AdjustAlpha(0.8));
#endif
}
gr.Dispose();
ctx.SetSourceSurface(bmp, rb.X, rb.Y);
ctx.Paint();
Clipping.Dispose();
Clipping = new Region();
}
/// <summary>
/// Parse all graphic elements
/// </summary>
private GraphicGroup ParseGroup(XNamespace ns, XElement groupElement, Matrix matrix)
{
var group = new GraphicGroup();
cssStyleCascade.PushStyles(groupElement);
Matrix currentTransformationMatrix = matrix;
var transform = cssStyleCascade.GetPropertyFromTop("transform");
if (!string.IsNullOrEmpty(transform))
{
var transformMatrix = TransformMatrixParser.GetTransformMatrix(transform);
currentTransformationMatrix = transformMatrix * currentTransformationMatrix;
}
Clipping.SetClipPath(group, currentTransformationMatrix, cssStyleCascade, globalDefinitions);
group.Opacity = cssStyleCascade.GetDoubleFromTop("opacity", 1);
var shapeParser = new ShapeParser();
foreach (var element in groupElement.Elements())
{
switch (element.Name.LocalName)
{
case "defs":
case "style":
// already read, ignore
break;
case "g":
case "svg":
{
var childGroup = ParseGroup(ns, element, currentTransformationMatrix);
group.Childreen.Add(childGroup);
break;
}
default:
{
var shape = shapeParser.Parse(element, ns, currentTransformationMatrix, cssStyleCascade, globalDefinitions);
if (shape != null)
{
group.Childreen.Add(shape);
}
break;
}
}
}
cssStyleCascade.Pop();
return(group);
}
/// <summary>
/// Add clip rectangle to this.clipping and propagate up to root
/// </summary>
/// <param name="clip">Clip rectangle</param>
public virtual void RegisterClip(Rectangle clip){
Rectangle r = clip + ClientRectangle.Position;
if (CacheEnabled && !IsDirty)
Clipping.AddRectangle (r);
if (Parent == null)
return;
GraphicObject p = Parent as GraphicObject;
if (p?.IsDirty == true && p?.CacheEnabled == true)
return;
Parent.RegisterClip (r + Slot.Position);
}
public void Deserialize_DifferentEdges_FromRoot()
{
// Arrange
const string json = "{\"Bottom\":0,\"Left\":false,\"Top\":10,\"Right\":-100}";
Clipping expected = new Clipping(top: 10, right: -100, bottom: 0, left: null);
// Act
Clipping deserialized = JsonConvert.DeserializeObject <Clipping>(json);
// Assert
Assert.Equal(expected, deserialized);
}
public void Deserialize_AllEdgesEqual_FromRoot(int value)
{
// Arrange
string json = value.ToString(CultureInfo.InvariantCulture);
Clipping expected = new Clipping(value);
// Act
Clipping deserialized = JsonConvert.DeserializeObject <Clipping>(json);
// Assert
Assert.Equal(expected, deserialized);
}
public void Serialize_DifferentEdges_AsRoot()
{
// Arrange
const string Expected = "{\"Top\":0,\"Right\":false,\"Bottom\":10,\"Left\":-100}";
Clipping clipping = new Clipping(top: 0, right: null, bottom: 10, left: -100);
// Act
string serialized = JsonConvert.SerializeObject(clipping);
// Assert
Assert.Equal(Expected, serialized);
}
private void AplicarClipping(Rueda rueda)
{
foreach (Poligono poligono in PoligonosTerreno)
{
poligono.Puntos = Clipping.RecortarPoligono(poligono.Puntos, new ViewPort(rueda));
}
foreach (Poligono poligono in PoligonosRueda)
{
poligono.Puntos = Clipping.RecortarPoligono(poligono.Puntos, new ViewPort(rueda));
}
}
public void Serialize_AllEdgesEqual_AsRoot(int value)
{
// Arrange
string Expected = value.ToString(CultureInfo.InvariantCulture);
Clipping clipping = new Clipping(value);
// Act
string serialized = JsonConvert.SerializeObject(clipping);
// Assert
Assert.Equal(Expected, serialized);
}
public void Deserialize_DifferentEdges_AdditionalMembers_FromRoot()
{
// Arrange
const string json = "{\"Left\":500,\"Top\":false,\"ABC\":19.2}";
Clipping expected = new Clipping(left: 500);
// Act
Clipping deserialized = JsonConvert.DeserializeObject <Clipping>(json);
// Assert
Assert.Equal(expected, deserialized);
}
public void Deserialize_DifferentEdges_MissingMembers_FromRoot()
{
// Arrange
const string json = "{\"Top\":-123,\"Right\":false}";
Clipping expected = new Clipping(top: -123);
// Act
Clipping deserialized = JsonConvert.DeserializeObject <Clipping>(json);
// Assert
Assert.Equal(expected, deserialized);
}
private void DrawEdge(
Vector4D point1,
Vector4D point2,
Color colour,
ref Matrix4x4 modelToView,
ref Matrix4x4 viewToScreen)
{
// Move the edge from model space to view space
point1 = modelToView * point1;
point2 = modelToView * point2;
// Clip the edge in view space
if (!Clipping.ClipEdges(ViewClippingPlanes, ref point1, ref point2))
{
return;
}
// Move the edge from view space to screen space, including a correction for perspective
point1 = viewToScreen * point1;
point2 = viewToScreen * point2;
if (this is PerspectiveCamera)
{
point1 /= point1.w;
point2 /= point2.w;
}
// Clip the edge in screen space
if (Settings.Screen_Space_Clip)
{
if (!Clipping.ClipEdges(ScreenClippingPlanes, ref point1, ref point2))
{
return;
}
}
// Mode the edge from screen space to window space
point1 = ScreenToWindow * point1;
point2 = ScreenToWindow * point2;
// Round the vertices
int resultPoint1X = point1.x.RoundToInt();
int resultPoint1Y = point1.y.RoundToInt();
float resultPoint1Z = point1.z;
int resultPoint2X = point2.x.RoundToInt();
int resultPoint2Y = point2.y.RoundToInt();
float resultPoint2Z = point2.z;
// Finally draw the line
Line(colour,
resultPoint1X, resultPoint1Y, resultPoint1Z,
resultPoint2X, resultPoint2Y, resultPoint2Z);
}
private void CreateClipping(IContentRootElement container, ImageSource imageSource)
{
#region radpdfprocessing-concepts-clipping_0
Clipping clipping = new Clipping();
clipping.Clip = new RectangleGeometry(new Rect(5, 5, 50, 50));
#endregion
#region radpdfprocessing-concepts-clipping_1
Image image = container.Content.AddImage(imageSource);
image.Clipping = clipping;
#endregion
}
private void button21_Click(object sender, EventArgs e)
{
if (coordinate.Count > 0)
{
var newCoordinates = Clipping.clipLiangBarsky(int.Parse(textBox1.Text), int.Parse(textBox2.Text), int.Parse(textBox3.Text), int.Parse(textBox4.Text), int.Parse(textBox5.Text), int.Parse(textBox7.Text), int.Parse(textBox6.Text), int.Parse(textBox8.Text));
Bitmap bmp = new Bitmap(pictureBox1.Image);
foreach (var item in newCoordinates)
{
bmp.SetPixel(pictureBox1.Size.Width / 2 + item.X, (bmp.Size.Height / 2 - item.Y), Color.Red);
}
pictureBox1.Image = bmp;
}
}
public void Equals_AllAndIndividual_ReturnsTrue()
{
// Arrange
const int Value = -10;
Clipping a = new Clipping(Value);
Clipping b = new Clipping(Value, Value, Value, Value);
// Act
bool equals = a.Equals(b);
// Assert
Assert.True(equals);
}
public void Equals_SameAll_ReturnsTrue()
{
// Arrange
const int Value = 10;
Clipping a = new Clipping(Value);
Clipping b = new Clipping(Value);
// Act
bool equals = a.Equals(b);
// Assert
Assert.True(equals);
}
/// <summary>
/// Update the renderer's materials.
/// </summary>
void UpdateMaterials()
{
bool useClipping = (mClipping != Clipping.None);
// Create a temporary material
if (mMat == null) RebuildMaterial();
// If clipping should be used, we need to find a replacement shader
if (useClipping && mClipping != Clipping.None)
{
Shader shader = null;
const string alpha = " (AlphaClip)";
const string soft = " (SoftClip)";
// Figure out the normal shader's name
string shaderName = mSharedMat.shader.name;
shaderName = shaderName.Replace(alpha, "");
shaderName = shaderName.Replace(soft, "");
// Try to find the new shader
if (mClipping == Clipping.SoftClip) shader = Shader.Find(shaderName + soft);
else shader = Shader.Find(shaderName + alpha);
// If there is a valid shader, assign it to the custom material
if (shader != null)
{
mMat.shader = shader;
}
else
{
mClipping = Clipping.None;
Debug.LogError(shaderName + " doesn't have a clipped shader version for " + mClipping);
}
}
if (mRen.sharedMaterial != mMat)
{
mRen.sharedMaterials = new Material[] { mMat };
}
}
public static void SetClipping(FrameworkElement element, Clipping value) { element.SetValue(ClippingProperty, value); }
public LocationBase(Clipping Clipping, string LineSegment)
{
this.clipping = Clipping;
this.lineSegment = LineSegment;
}
private void CreateMaterial()
{
Shader shader;
string name = (this.mMaterial == null) ? ((this.mMaterial == null) ? "Unlit/Transparent Colored" : this.mMaterial.shader.name) : this.mShader.name;
name = name.Replace("GUI/Text Shader", "Unlit/Text").Replace(" (AlphaClip)", string.Empty).Replace(" (SoftClip)", string.Empty);
if (this.mClipping == Clipping.SoftClip)
{
shader = Shader.Find(name + " (SoftClip)");
}
else if (this.mClipping == Clipping.AlphaClip)
{
shader = Shader.Find(name + " (AlphaClip)");
}
else
{
shader = (this.mShader == null) ? Shader.Find(name) : this.mShader;
}
if (this.mMaterial != null)
{
this.mDynamicMat = new Material(this.mMaterial);
this.mDynamicMat.hideFlags = HideFlags.DontSave;
this.mDynamicMat.CopyPropertiesFromMaterial(this.mMaterial);
if (shader != null)
{
this.mDynamicMat.shader = shader;
}
else if (this.mClipping != Clipping.None)
{
Debug.LogError(name + " doesn't have a clipped shader version for " + this.mClipping);
this.mClipping = Clipping.None;
}
}
else
{
this.mDynamicMat = new Material(shader);
this.mDynamicMat.hideFlags = HideFlags.DontSave;
}
}
private Material RebuildMaterial()
{
NGUITools.DestroyImmediate(this.mDynamicMat);
this.CreateMaterial();
this.mDynamicMat.renderQueue = ((this.mMaterial == null) ? 0xbb8 : this.mMaterial.renderQueue) + this.mRenderQueue;
this.mLastClip = this.mClipping;
if (this.mTexture != null)
{
this.mDynamicMat.mainTexture = this.mTexture;
}
if (this.mRenderer != null)
{
this.mRenderer.sharedMaterials = new Material[] { this.mDynamicMat };
}
return this.mDynamicMat;
}
/// <summary>
/// Update the renderer's materials.
/// </summary>
void UpdateMaterials()
{
bool useClipping = (mClipping != Clipping.None);
// Create a temporary material
if (mMat == null)
{
mMat = new Material(mSharedMat);
mMat.hideFlags = HideFlags.DontSave;
mMat.CopyPropertiesFromMaterial(mSharedMat);
mMat.renderQueue = mSharedMat.renderQueue + mDepth;
}
// If clipping should be used, we need to find a replacement shader
if (useClipping && mClipping != Clipping.None)
{
Shader shader = null;
const string alpha = " (AlphaClip)";
const string soft = " (SoftClip)";
// Figure out the normal shader's name
string shaderName = mSharedMat.shader.name;
shaderName = shaderName.Replace(alpha, "");
shaderName = shaderName.Replace(soft, "");
// Try to find the new shader
if (mClipping == Clipping.HardClip ||
mClipping == Clipping.AlphaClip) shader = Shader.Find(shaderName + alpha);
else if (mClipping == Clipping.SoftClip) shader = Shader.Find(shaderName + soft);
// If there is a valid shader, assign it to the custom material
if (shader != null)
{
mMat.shader = shader;
}
else
{
mClipping = Clipping.None;
Debug.LogError(shaderName + " doesn't have a clipped shader version for " + mClipping);
}
}
// If depth pass should be used, create the depth material
if (mUseDepth)
{
if (mDepthMat == null)
{
Shader shader = Shader.Find("Unlit/Depth Cutout");
mDepthMat = new Material(shader);
mDepthMat.hideFlags = HideFlags.DontSave;
}
mDepthMat.mainTexture = mSharedMat.mainTexture;
}
else if (mDepthMat != null)
{
NGUITools.Destroy(mDepthMat);
mDepthMat = null;
}
if (mDepthMat != null)
{
// If we're already using this material, do nothing
if (mRen.sharedMaterials != null && mRen.sharedMaterials.Length == 2 && mRen.sharedMaterials[1] == mMat) return;
// Set the double material
mRen.sharedMaterials = new Material[] { mDepthMat, mMat };
}
else if (mRen.sharedMaterial != mMat)
{
mRen.sharedMaterials = new Material[] { mMat };
}
}
public Location(Clipping Clipping, string Line)
: base(Clipping, Line)
{
}
/// <summary>
/// Update the renderer's materials.
/// </summary>
void UpdateMaterials()
{
bool useClipping = (mClipping != Clipping.None);
// If clipping should be used, create the clipped material
if (useClipping)
{
Shader shader = null;
if (mClipping != Clipping.None)
{
const string hard = " (HardClip)";
const string alpha = " (AlphaClip)";
const string soft = " (SoftClip)";
// Figure out the normal shader's name
string shaderName = mSharedMat.shader.name;
shaderName = shaderName.Replace(hard, "");
shaderName = shaderName.Replace(alpha, "");
shaderName = shaderName.Replace(soft, "");
// Try to find the new shader
if (mClipping == Clipping.HardClip) shader = Shader.Find(shaderName + hard);
else if (mClipping == Clipping.AlphaClip) shader = Shader.Find(shaderName + alpha);
else if (mClipping == Clipping.SoftClip) shader = Shader.Find(shaderName + soft);
// If there is a valid shader, assign it to the custom material
if (shader == null) mClipping = Clipping.None;
}
// If we found the shader, create a new material
if (shader != null)
{
mClippedMat = new Material(mSharedMat);
mClippedMat.shader = shader;
}
}
else if (mClippedMat != null)
{
NGUITools.Destroy(mClippedMat);
mClippedMat = null;
}
// If depth pass should be used, create the depth material
if (mDepthPass)
{
if (mDepthMat == null)
{
Shader shader = Shader.Find("Depth");
mDepthMat = new Material(shader);
mDepthMat.mainTexture = mSharedMat.mainTexture;
}
}
else if (mDepthMat != null)
{
NGUITools.Destroy(mDepthMat);
mDepthMat = null;
}
// Determine which material should be used
Material mat = (mClippedMat != null) ? mClippedMat : mSharedMat;
if (mDepthMat != null)
{
// If we're already using this material, do nothing
if (mRen.sharedMaterials != null && mRen.sharedMaterials.Length == 2 && mRen.sharedMaterials[1] == mat) return;
// Set the double material
mRen.sharedMaterials = new Material[] { mDepthMat, mat };
}
else if (mRen.sharedMaterial != mat)
{
mRen.sharedMaterials = new Material[] { mat };
}
}
/// <summary>
/// Create an appropriate material for the draw call.
/// </summary>
void CreateMaterial ()
{
const string alpha = " (AlphaClip)";
const string soft = " (SoftClip)";
string shaderName = (mShader != null) ? mShader.name :
((mMaterial != null) ? mMaterial.shader.name : "Unlit/Transparent Colored");
// Figure out the normal shader's name
shaderName = shaderName.Replace("GUI/Text Shader", "Unlit/Text");
shaderName = shaderName.Replace(alpha, "");
shaderName = shaderName.Replace(soft, "");
// Try to find the new shader
Shader shader;
if (mClipping == Clipping.SoftClip)
{
shader = Shader.Find(shaderName + soft);
}
else if (mClipping == Clipping.AlphaClip)
{
shader = Shader.Find(shaderName + alpha);
}
else // No clipping
{
shader = (mShader != null) ? mShader : Shader.Find(shaderName);
}
if (mMaterial != null)
{
mDynamicMat = new Material(mMaterial);
mDynamicMat.hideFlags = HideFlags.DontSave;
mDynamicMat.CopyPropertiesFromMaterial(mMaterial);
// If there is a valid shader, assign it to the custom material
if (shader != null)
{
mDynamicMat.shader = shader;
}
else if (mClipping != Clipping.None)
{
Debug.LogError(shaderName + " doesn't have a clipped shader version for " + mClipping);
mClipping = Clipping.None;
}
}
else
{
mDynamicMat = new Material(shader);
mDynamicMat.hideFlags = HideFlags.DontSave;
}
}
/// <summary>
/// Rebuild the draw call's material.
/// </summary>
Material RebuildMaterial ()
{
// Destroy the old material
NGUITools.DestroyImmediate(mDynamicMat);
// Create a new material
CreateMaterial();
// Material's render queue generally begins at 3000
mDynamicMat.renderQueue = ((mMaterial != null) ? mMaterial.renderQueue : 3000) + mRenderQueue;
mLastClip = mClipping;
// Assign the main texture
if (mTexture != null) mDynamicMat.mainTexture = mTexture;
// Update the renderer
if (mRenderer != null) mRenderer.sharedMaterials = new Material[] { mDynamicMat };
return mDynamicMat;
}
public PageNumber(Clipping Clipping, string Line)
: base(Clipping, Line)
{
}
