private Affine2D CalcDragTranslation() { Affine2D result = dragSrcTransform; Vec2 newPos = new Vec2(); if ((dragModifier & DragModifier.Shift) == DragModifier.Shift) { Vec2 norm = mouseWorldPos.GetNormal(); if ((dragModifier & DragModifier.Ctrl) == DragModifier.Ctrl) { norm.SnapToNormalizedAngle(12); } newPos = norm * dragSrcTransform.Translation.Length; } else { if ((dragModifier & DragModifier.Ctrl) == DragModifier.Ctrl) { newPos = snapToGrid(mouseWorldPos); } else { newPos = mouseWorldPos + dragHandleOffset; } } result.Translation = newPos; dragHandlePos = result.Translation; return(result); }
//adjust the camera's rotation/scale so that screenMousePos will align with the world target private void CameraRotateScale(Vec2 screenMousePos, Vec2 worldTarget) { Vec2 v = ScreenToView(screenMousePos); Affine2D ct = FractalManager.CameraTransform; //first figure out if the camera is flipped float k; float cz = ct.XAxis.X * ct.YAxis.Y - ct.XAxis.Y * ct.YAxis.X; if (cz > 0) { k = 1.0f; } else { k = -1.0f; } //compute the new cam matrix float rsq = v.X * v.X + v.Y * v.Y; float a = k * (v.Y * (worldTarget.Y - ct.F) + k * v.X * (worldTarget.X - ct.C)) / rsq; float d = -k * (v.Y * (worldTarget.X - ct.C) + k * v.X * (ct.F - worldTarget.Y)) / rsq; ct.A = a; ct.D = d; ct.B = -k * d; ct.E = k * a; FractalManager.CameraTransform = ct; }
public static void GLMultAffineMatrix(Affine2D a) { float[] vals = new float[] { a.XAxis.X, a.XAxis.Y, 0.0f, 0.0f, a.YAxis.X, a.YAxis.Y, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, a.Translation.X, a.Translation.Y, 0.0f, 1.0f }; GL.MultMatrix(vals); }
public static void GLLoadAffineMatrix(Affine2D a, float z) { float[] vals = new float[] { a.XAxis.X, a.XAxis.Y, 0.0f, 0.0f, a.YAxis.X, a.YAxis.Y, 0.0f, 0.0f, 0.0f, 0.0f, z, 0.0f, a.Translation.X, a.Translation.Y, 0.0f, 1.0f }; GL.LoadMatrix(vals); }
public static void ChangeZoom(float ammount) { Affine2D ct = FractalManager.CameraTransform; ct.XAxis /= ammount; ct.YAxis /= ammount; FractalManager.CameraTransform = ct; }
public Branch() { Transform = new Affine2D(0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f); Localized = false; Chroma = new Vec2(0.5f, 0.5f); Weight = 1.0f; ColorWeight = 0.5f; variations = new List <VariEntry>(); variations.Add(new VariEntry(0, 1.0f)); }
//adjust the camera's position so that screenMousePos will align with the world target private void Pan(Vec2 screenMousePos, Vec2 worldTarget) { Vec2 viewMousePos = ScreenToView(screenMousePos); Affine2D ct = FractalManager.CameraTransform; ct.Translation.X = worldTarget.X - ct.XAxis.X * viewMousePos.X - ct.YAxis.X * viewMousePos.Y; ct.Translation.Y = worldTarget.Y - ct.XAxis.Y * viewMousePos.X - ct.YAxis.Y * viewMousePos.Y; FractalManager.CameraTransform = ct; }
public RenderControl() : base() { ResizeRedraw = true; FractalManager.GeometryChanged += (frac) => { UpdateTransforms(); }; viewTransform = Affine2D.Identity; projTransform = Affine2D.Identity; screenTransform = Affine2D.Identity; }
public KLEITexture(BinaryReader reader) { signature = reader.ReadBytes(8); StructSize = reader.ReadUInt32(); ParentSurfaceResourceIdx = reader.ReadUInt32(); Width = reader.ReadUInt32(); Height = reader.ReadUInt32(); Affine2d = new Affine2D(reader); }
public Branch(Branch src) { Transform = src.Transform; Localized = src.Localized; Chroma = src.Chroma; Weight = src.Weight; ColorWeight = src.ColorWeight; variations = new List <VariEntry>(); foreach (VariEntry v in src.Variations) { variations.Add(v); } }
protected override void OnMouseDown(MouseEventArgs ea) { if (!SafeToRender) { return; } Focus(); mouseWorldPos = WindowToWorld(ea.X, ea.Y); if (dragState == DragState.None) { if (EditMode && ea.Button == MouseButtons.Left) { UpdateHover(WindowToScreen(ea.X, ea.Y)); FractalManager.SelectedBranch = hoverBranch; if (hoverBranch != null) { mouseDownWorldPos = mouseWorldPos; dragSrcTransform = hoverBranch.Transform; dragHandlePos = hoverHandlePos; dragHandleOffset = dragHandlePos - mouseWorldPos; dragState = DragState.Dragging; Capture = true; } else { dragState = DragState.Panning; Capture = true; mouseDownWorldPos = mouseWorldPos; } } else if (ea.Button == MouseButtons.Middle) { dragState = DragState.Panning; Capture = true; mouseDownWorldPos = mouseWorldPos; } else if (ea.Button == MouseButtons.Right) { if (EditMode) { UpdateHover(WindowToScreen(ea.X, ea.Y)); FractalManager.SelectedBranch = hoverBranch; } dragState = DragState.RotateScale; Capture = true; mouseDownWorldPos = mouseWorldPos; } } }
private void UpdateTransforms() { float invAspectRatio = (ClientSize.Width > 0) ? ((float)ClientSize.Height / (float)ClientSize.Width) : 0.0f; viewTransform = FractalManager.CameraTransform.Inverse; projTransform = new Affine2D(invAspectRatio, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f); float xHalf = (float)ClientSize.Width / 2.0f; float yHalf = (float)ClientSize.Height / 2.0f; screenTransform = new Affine2D(xHalf, 0.0f, 0.0f, yHalf, xHalf, yHalf); vpsTransform = screenTransform * projTransform * viewTransform; vpsInverse = vpsTransform.Inverse; }
private Affine2D CalcDragYAxis() { Affine2D result = dragSrcTransform; Vec2 targetPos; Vec2 newAxis; if ((dragModifier & DragModifier.Shift) == DragModifier.Shift) { //if((dragModifier&DragModifier.Ctrl) == DragModifier.Ctrl) // targetPos = snapToGrid(mouseWorldPos); Vec2 targetAxis = mouseWorldPos - dragSrcTransform.Translation; Vec2 norm = targetAxis.GetNormal(); if ((dragModifier & DragModifier.Ctrl) == DragModifier.Ctrl) { norm.SnapToNormalizedAngle(24); } newAxis = norm * dragSrcTransform.YAxis.Length; } else { if ((dragModifier & DragModifier.Ctrl) == DragModifier.Ctrl) { targetPos = snapToGrid(mouseWorldPos); } else { targetPos = mouseWorldPos + dragHandleOffset; } newAxis = targetPos - dragSrcTransform.Translation; } if ((dragModifier & DragModifier.Alt) == DragModifier.Alt) { result.YAxis = newAxis; } else { result.RotateScaleYTo(newAxis); } dragHandlePos = result.Translation + result.YAxis; return(result); }
private static void readAffine2D(XmlNode node, ref Affine2D value) { foreach (XmlNode child in node.ChildNodes) { if (child.Name == "XAxis") { readVec2Elem(child, ref value.XAxis); } else if (child.Name == "YAxis") { readVec2Elem(child, ref value.YAxis); } else if (child.Name == "Translation") { readVec2Elem(child, ref value.Translation); } } }
public override void ApplyParameters(Fractal fractal) { if (!IsAllocated()) { return; } fractal.FillNativeFractal(xRes, yRes, this.fractal, this.branches, this.variWeights); foreach (Iterator iter in iterators) { iter.SetFractal(this.fractal, this.branches, this.variWeights); } float invAspectRatio = (xRes > 0) ? ((float)yRes / (float)xRes) : 0.0f; viewTransform = FractalManager.CameraTransform.Inverse; projTransform = new Affine2D(invAspectRatio, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f); }
public Fractal(Fractal src) { this.Name = src.Name; this.Version = src.Version; this.CameraTransform = src.CameraTransform; this.Brightness = src.Brightness; this.Gamma = src.Gamma; this.Vibrancy = src.Vibrancy; this.BackgroundColor = src.BackgroundColor; this.Branches = new List <Branch>(); foreach (Branch branch in src.Branches) { Branches.Add(new Branch(branch)); } this.palette = src.Palette; this.OriginalXml = src.OriginalXml; }
public Fractal() { CameraTransform = new Affine2D(2.0f, 0.0f, 0.0f, 2.0f, 0.0f, 0.0f); Branches = new List <Branch>(); }
public static void GLLoadAffineMatrix(Affine2D a) { GLLoadAffineMatrix(a, 1.0f); }
public override void ApplyParameters(Fractal fractal) { context.Synchronize(); mainStream.Synchronize(); float invAspectRatio = (XRes > 0) ? ((float)YRes / (float)XRes) : 0.0f; Affine2D viewTransform = fractal.CameraTransform.Inverse; Affine2D projTransform = new Affine2D(invAspectRatio, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f); float xHalf = (float)XRes / 2.0f; float yHalf = (float)YRes / 2.0f; Affine2D screenTransform = new Affine2D(xHalf, 0.0f, 0.0f, yHalf, xHalf, yHalf); vpsTransform = screenTransform * projTransform * viewTransform; module.WriteConstant("vpsTransform", vpsTransform); module.WriteConstant("brightness", fractal.Brightness); float invGamma = 1.0f / fractal.Gamma; module.WriteConstant("invGamma", invGamma); module.WriteConstant("vibrancy", fractal.Vibrancy); module.WriteConstant("bgColor", fractal.BackgroundColor); Int32 branchCount = Math.Min(MaxBranches, fractal.Branches.Count); module.WriteConstant("branchCount", branchCount); Affine2D[] branchPreTransforms = new Affine2D[MaxBranches]; Affine2D[] branchPostTransforms = new Affine2D[MaxBranches]; float[] branchLumas = new float[MaxBranches]; Vec2[] branchChromas = new Vec2[MaxBranches]; float[] branchFactors = new float[MaxBranches * MaxFactors]; UInt32[] branchNormWeights = new UInt32[MaxBranches]; branchNormWeights.AssignAll((i) => (UInt32)0x00010000); float branchWeightSum = 0.0f; for (int bi = 0; bi < branchCount; bi++) { branchWeightSum += fractal.Branches[bi].Weight; } float[] branchColorWeights = new float[MaxBranches]; UInt32 runningSum = 0; for (int bi = 0; bi < branchCount; bi++) { Branch branch = fractal.Branches[bi]; branchPreTransforms[bi] = branch.PreTransform; branchPostTransforms[bi] = branch.PostTransform; branchLumas[bi] = branch.Luma; branchChromas[bi] = branch.Chroma; runningSum += (UInt32)(branch.Weight / branchWeightSum * 65536.0f); if (bi < branchCount - 1) { branchNormWeights[bi] = runningSum; } else { branchNormWeights[bi] = 0x00010000; } branchColorWeights[bi] = branch.ColorWeight; foreach (Branch.VariEntry ve in branch.Variations) { if (ve.Index >= 0 && ve.Index < MaxFactors) { branchFactors[MaxFactors * bi + ve.Index] += ve.Weight; } } } module.WriteConstant("branchPreTransforms", branchPreTransforms); module.WriteConstant("branchPostTransforms", branchPostTransforms); module.WriteConstant("branchLumas", branchLumas); module.WriteConstant("branchChromas", branchChromas); module.WriteConstant("branchNormWeights", branchNormWeights); module.WriteConstant("branchColorWeights", branchColorWeights); module.WriteConstant("branchFactors", branchFactors); context.Synchronize(); }
unsafe public void FillNativeFractal(int xRes, int yRes, NativeFractal *nFractal, NativeBranch *nBranches, float *nVariWeights) { Int32 branchCount = Math.Min(NativeFractal.MaxBranches, this.Branches.Count); nFractal->BranchCount = (uint)branchCount; float invAspectRatio = (xRes > 0) ? ((float)yRes / (float)xRes) : 0.0f; Affine2D viewTransform = this.CameraTransform.Inverse; Affine2D projTransform = new Affine2D(invAspectRatio, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f); float xHalf = (float)xRes / 2.0f; float yHalf = (float)yRes / 2.0f; Affine2D screenTransform = new Affine2D(xHalf, 0.0f, 0.0f, yHalf, xHalf, yHalf); nFractal->VpsTransform = screenTransform * projTransform * viewTransform; nFractal->Brightness = this.Brightness; nFractal->InvGamma = 1.0f / this.Gamma; nFractal->Vibrancy = this.Vibrancy; nFractal->BgColor = this.BackgroundColor; for (int bi = 0; bi < branchCount; bi++) { nBranches[bi].NormWeight = (UInt32)0x00010000; } float branchWeightSum = 0.0f; for (int bi = 0; bi < branchCount; bi++) { branchWeightSum += this.Branches[bi].Weight; } for (int i = 0; i < NativeFractal.MaxBranches * NativeFractal.MaxVariations; i++) { nVariWeights[i] = 0.0f; } UInt32 runningSum = 0; for (int bi = 0; bi < branchCount; bi++) { Branch branch = this.Branches[bi]; runningSum += (UInt32)(branch.Weight / branchWeightSum * 65536.0f); if (bi < branchCount - 1) { nBranches[bi].NormWeight = runningSum; } else { nBranches[bi].NormWeight = 0x00010000; } nBranches[bi].ColorWeight = branch.ColorWeight; nBranches[bi].Chroma = branch.Chroma; nBranches[bi].PreTransform = branch.PreTransform; nBranches[bi].PostTransform = branch.PostTransform; foreach (Branch.VariEntry ve in branch.Variations) { if (ve.Index >= 0 && ve.Index < NativeFractal.MaxVariations) { nVariWeights[bi * NativeFractal.MaxVariations + ve.Index] += ve.Weight; } } } }
private static Branch readBranchNode(XmlNode node) { Branch branch = new Branch(); branch.Variations.Clear(); Affine2D pre = Affine2D.Identity; Affine2D post = Affine2D.Identity; bool foundPost = false; bool foundLocalized = false; foreach (XmlAttribute attr in node.Attributes) { if (attr.Name == "weight") { readFloatAttr(attr, ref branch.Weight); } else if (attr.Name == "coefs") { try{ string[] coefArr = attr.Value.Split((char[])null, StringSplitOptions.RemoveEmptyEntries); pre.XAxis.X = float.Parse(coefArr[0]); pre.XAxis.Y = float.Parse(coefArr[1]); pre.YAxis.X = float.Parse(coefArr[2]); pre.YAxis.Y = float.Parse(coefArr[3]); pre.Translation.X = float.Parse(coefArr[4]); pre.Translation.Y = float.Parse(coefArr[5]); } catch (Exception) { pre = Affine2D.Identity; } } else if (attr.Name == "post") { try{ string[] coefArr = attr.Value.Split((char[])null, StringSplitOptions.RemoveEmptyEntries); post.XAxis.X = float.Parse(coefArr[0]); post.XAxis.Y = float.Parse(coefArr[1]); post.YAxis.X = float.Parse(coefArr[2]); post.YAxis.Y = float.Parse(coefArr[3]); post.Translation.X = float.Parse(coefArr[4]); post.Translation.Y = float.Parse(coefArr[5]); foundPost = true; } catch (Exception) { post = Affine2D.Identity; } } else if (attr.Name == "vars") //found old style variations { try{ string[] varArr = attr.Value.Split((char[])null, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < varArr.Length && i < 14; i++) { float weight = float.Parse(varArr[i]); if (weight != 0.0f) { branch.Variations.Add(new Branch.VariEntry(i, weight)); } } } catch (Exception) { } } else if (attr.Name == "color") { try{ string[] colorStr = node.Attributes["color"].Value.Split((char[])null, StringSplitOptions.RemoveEmptyEntries); if (colorStr.Length >= 1) { branch.Chroma.X = float.Parse(colorStr[0]); } if (colorStr.Length >= 2) { branch.Chroma.Y = float.Parse(colorStr[1]); } }catch (Exception) {} } else if (attr.Name == "f9k_color2") { readFloatAttr(attr, ref branch.Chroma.Y); } else if (attr.Name == "f9k_colorweight") { readFloatAttr(attr, ref branch.ColorWeight); } else if (attr.Name == "f9k_localized") { int iLocalized = 0; readIntAttr(attr, ref iLocalized); foundLocalized = (iLocalized == 1); } else { //see if the attribute is a known variation name int idx = -1; for (int i = 0; i < Variation.Count; i++) { if (Variation.Variations[i].AttrName == attr.Name) { idx = i; } } //yep, its a known variation if (idx >= 0 && idx < Variation.Count) { float weight = 0; readFloatAttr(attr, ref weight); branch.Variations.Add(new Branch.VariEntry(idx, weight)); } } } //figure out whether or not to treat this as a localized branch if (foundLocalized) { //the branch is tagged as localized, so this is easy branch.Localized = true; branch.Transform = pre; } else if (foundPost) { Affine2D postInv = post.Inverse; if (pre.Equals(postInv, 0.001f)) { //The post transform is roughly the inverse of the pre, so this is probably supposed to be localized branch.Localized = true; branch.Transform = post; } else { //The post isn't the inverse of the pre. Discard the post since the current UI can't deal with it. branch.Localized = false; branch.Transform = pre; } } else { //just a plain old non-localized branch. branch.Localized = false; branch.Transform = pre; } //if no variations at all could be found, assume linear if (branch.Variations.Count == 0) { branch.Variations.Add(new Branch.VariEntry(0, 1.0f)); } return(branch); }