public void Init(float voxelsPerMeter, int chunkMeterSizeX, int chunkMeterSizeY, int chunkMeterSizeZ)
{
VoxelsPerMeter = voxelsPerMeter;
ChunkMeterSizeX = chunkMeterSizeX;
ChunkMeterSizeY = chunkMeterSizeY;
ChunkMeterSizeZ = chunkMeterSizeZ;
CalculateVariables();
Sampler.SetChunkSettings(VoxelsPerMeter,
new Vector3Int(ChunkSizeX, ChunkSizeY, ChunkSizeZ),
new Vector3Int(ChunkMeterSizeX, ChunkMeterSizeY, ChunkMeterSizeZ),
skipDist,
half,
new Vector3(xSideLength, ySideLength, zSideLength));
col_data = new ColumnResult();
col_data.SurfaceData = new float[(ChunkSizeX + 2) * (ChunkSizeZ + 2)];
if (VoxelServer.Instance.Gpu_Acceloration)
{
GPU_ColumnBuilder _builder = new GPU_ColumnBuilder(col_data, Sampler);
_builder.Init(Location, VoxelsPerMeter, ChunkMeterSizeX, ChunkMeterSizeY, ChunkMeterSizeZ);
builder = _builder;
}
else
{
StandardColumnBuilder _builder = new StandardColumnBuilder(col_data, Sampler);
_builder.Init(Location, VoxelsPerMeter, ChunkMeterSizeX, ChunkMeterSizeY, ChunkMeterSizeZ);
builder = _builder;
}
}
internal ReadOnlyCollection <ColumnResult> GetColumnResults(out bool hasTextContent)
{
Invariant.Assert(!this.IsDisposed);
List <ColumnResult> list = new List <ColumnResult>(0);
hasTextContent = false;
if (!(this._ptsPage.PageHandle == IntPtr.Zero))
{
PTS.FSPAGEDETAILS fspagedetails;
PTS.Validate(PTS.FsQueryPageDetails(this.StructuralCache.PtsContext.Context, this._ptsPage.PageHandle, out fspagedetails));
if (PTS.ToBoolean(fspagedetails.fSimple))
{
PTS.FSTRACKDETAILS fstrackdetails;
PTS.Validate(PTS.FsQueryTrackDetails(this.StructuralCache.PtsContext.Context, fspagedetails.u.simple.trackdescr.pfstrack, out fstrackdetails));
if (fstrackdetails.cParas > 0)
{
list = new List <ColumnResult>(1);
ColumnResult columnResult = new ColumnResult(this, ref fspagedetails.u.simple.trackdescr, default(Vector));
list.Add(columnResult);
if (columnResult.HasTextContent)
{
hasTextContent = true;
}
}
}
else if (fspagedetails.u.complex.cSections > 0)
{
PTS.FSSECTIONDESCRIPTION[] array;
PtsHelper.SectionListFromPage(this.StructuralCache.PtsContext, this._ptsPage.PageHandle, ref fspagedetails, out array);
PTS.FSSECTIONDETAILS fssectiondetails;
PTS.Validate(PTS.FsQuerySectionDetails(this.StructuralCache.PtsContext.Context, array[0].pfssection, out fssectiondetails));
if (PTS.ToBoolean(fssectiondetails.fFootnotesAsPagenotes) && fssectiondetails.u.withpagenotes.cBasicColumns > 0)
{
PTS.FSTRACKDESCRIPTION[] array2;
PtsHelper.TrackListFromSection(this.StructuralCache.PtsContext, array[0].pfssection, ref fssectiondetails, out array2);
list = new List <ColumnResult>(fssectiondetails.u.withpagenotes.cBasicColumns);
foreach (PTS.FSTRACKDESCRIPTION fstrackdescription in array2)
{
if (fstrackdescription.pfstrack != IntPtr.Zero)
{
PTS.FSTRACKDETAILS fstrackdetails2;
PTS.Validate(PTS.FsQueryTrackDetails(this.StructuralCache.PtsContext.Context, fstrackdescription.pfstrack, out fstrackdetails2));
if (fstrackdetails2.cParas > 0)
{
ColumnResult columnResult2 = new ColumnResult(this, ref fstrackdescription, default(Vector));
list.Add(columnResult2);
if (columnResult2.HasTextContent)
{
hasTextContent = true;
}
}
}
}
}
}
}
Invariant.Assert(list != null);
return(new ReadOnlyCollection <ColumnResult>(list));
}
public GameColumns(ColumnBase.ChangeColumnDelegate alignDeckSequence)
{
ColResult = new ColumnResult[AdditionalData.CountResultColumns];
ColGame = new ColumnGame[AdditionalData.CountGameColumns];
ColAdditional = new AdditionalColumn[2];
ColDeck = new ColumnDeck();
InitializeColumns(alignDeckSequence);
}
//-------------------------------------------------------------------
//
// Private Methods
//
//-------------------------------------------------------------------
#region Private Methods
// This method calculates the height of the first line if the element is TextBlock or FlowDocumentScrollViewer
// Otherwise returns the element height
private double GetFirstLineHeight(UIElement element)
{
// We need to find TextBlock/FlowDocumentScrollViewer if it is nested inside ContentPresenter
// Common scenario when used in styles is that BulletDecorator content is a ContentPresenter
UIElement text = FindText(element);
ReadOnlyCollection <LineResult> lr = null;
if (text != null)
{
TextBlock textElement = ((TextBlock)text);
if (textElement.IsLayoutDataValid)
{
lr = textElement.GetLineResults();
}
}
else
{
text = FindFlowDocumentScrollViewer(element);
if (text != null)
{
TextDocumentView tdv = ((IServiceProvider)text).GetService(typeof(ITextView)) as TextDocumentView;
if (tdv != null && tdv.IsValid)
{
ReadOnlyCollection <ColumnResult> cr = tdv.Columns;
if (cr != null && cr.Count > 0)
{
ColumnResult columnResult = cr[0];
ReadOnlyCollection <ParagraphResult> pr = columnResult.Paragraphs;
if (pr != null && pr.Count > 0)
{
ContainerParagraphResult cpr = pr[0] as ContainerParagraphResult;
if (cpr != null)
{
TextParagraphResult textParagraphResult = cpr.Paragraphs[0] as TextParagraphResult;
if (textParagraphResult != null)
{
lr = textParagraphResult.Lines;
}
}
}
}
}
}
}
if (lr != null && lr.Count > 0)
{
Point ancestorOffset = new Point();
text.TransformToAncestor(element).TryTransform(ancestorOffset, out ancestorOffset);
return(lr[0].LayoutBox.Height + ancestorOffset.Y * 2d);
}
return(element.RenderSize.Height);
}
// Token: 0x06005BFA RID: 23546 RVA: 0x0019DB54 File Offset: 0x0019BD54
private double GetFirstLineHeight(UIElement element)
{
UIElement uielement = this.FindText(element);
ReadOnlyCollection <LineResult> readOnlyCollection = null;
if (uielement != null)
{
TextBlock textBlock = (TextBlock)uielement;
if (textBlock.IsLayoutDataValid)
{
readOnlyCollection = textBlock.GetLineResults();
}
}
else
{
uielement = this.FindFlowDocumentScrollViewer(element);
if (uielement != null)
{
TextDocumentView textDocumentView = ((IServiceProvider)uielement).GetService(typeof(ITextView)) as TextDocumentView;
if (textDocumentView != null && textDocumentView.IsValid)
{
ReadOnlyCollection <ColumnResult> columns = textDocumentView.Columns;
if (columns != null && columns.Count > 0)
{
ColumnResult columnResult = columns[0];
ReadOnlyCollection <ParagraphResult> paragraphs = columnResult.Paragraphs;
if (paragraphs != null && paragraphs.Count > 0)
{
ContainerParagraphResult containerParagraphResult = paragraphs[0] as ContainerParagraphResult;
if (containerParagraphResult != null)
{
TextParagraphResult textParagraphResult = containerParagraphResult.Paragraphs[0] as TextParagraphResult;
if (textParagraphResult != null)
{
readOnlyCollection = textParagraphResult.Lines;
}
}
}
}
}
}
}
if (readOnlyCollection != null && readOnlyCollection.Count > 0)
{
Point inPoint = default(Point);
uielement.TransformToAncestor(element).TryTransform(inPoint, out inPoint);
return(readOnlyCollection[0].LayoutBox.Height + inPoint.Y * 2.0);
}
return(element.RenderSize.Height);
}
internal ReadOnlyCollection <ColumnResult> GetColumnResults(out bool hasTextContent)
{
List <ColumnResult> list = new List <ColumnResult>(0);
Vector contentOffset = default(Vector);
hasTextContent = false;
PTS.FSSUBPAGEDETAILS fssubpagedetails;
PTS.Validate(PTS.FsQuerySubpageDetails(base.PtsContext.Context, this._paraHandle.Value, out fssubpagedetails));
if (PTS.ToBoolean(fssubpagedetails.fSimple))
{
PTS.FSTRACKDETAILS fstrackdetails;
PTS.Validate(PTS.FsQueryTrackDetails(base.PtsContext.Context, fssubpagedetails.u.simple.trackdescr.pfstrack, out fstrackdetails));
if (fstrackdetails.cParas > 0)
{
list = new List <ColumnResult>(1);
ColumnResult columnResult = new ColumnResult(this, ref fssubpagedetails.u.simple.trackdescr, contentOffset);
list.Add(columnResult);
if (columnResult.HasTextContent)
{
hasTextContent = true;
}
}
}
else if (fssubpagedetails.u.complex.cBasicColumns != 0)
{
PTS.FSTRACKDESCRIPTION[] array;
PtsHelper.TrackListFromSubpage(base.PtsContext, this._paraHandle.Value, ref fssubpagedetails, out array);
list = new List <ColumnResult>(fssubpagedetails.u.complex.cBasicColumns);
for (int i = 0; i < array.Length; i++)
{
PTS.FSTRACKDETAILS fstrackdetails2;
PTS.Validate(PTS.FsQueryTrackDetails(base.PtsContext.Context, array[i].pfstrack, out fstrackdetails2));
if (fstrackdetails2.cParas > 0)
{
ColumnResult columnResult2 = new ColumnResult(this, ref array[i], contentOffset);
list.Add(columnResult2);
if (columnResult2.HasTextContent)
{
hasTextContent = true;
}
}
}
}
return(new ReadOnlyCollection <ColumnResult>(list));
}
// Token: 0x0600651B RID: 25883 RVA: 0x001C6334 File Offset: 0x001C4534
private static void DumpColumnResults(XmlTextWriter writer, ReadOnlyCollection <ColumnResult> columns, Visual visualParent)
{
if (columns != null)
{
writer.WriteStartElement("Columns");
writer.WriteAttributeString("Count", columns.Count.ToString(CultureInfo.InvariantCulture));
for (int i = 0; i < columns.Count; i++)
{
writer.WriteStartElement("Column");
ColumnResult columnResult = columns[i];
LayoutDump.DumpRect(writer, "LayoutBox", columnResult.LayoutBox);
LayoutDump.DumpTextRange(writer, columnResult.StartPosition, columnResult.EndPosition);
LayoutDump.DumpParagraphResults(writer, "Paragraphs", columnResult.Paragraphs, visualParent);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
}
public Columns()
{
ColResult = new ColumnResult[StaticGameData.CountResultColumns];
ColGame = new ColumnGame[StaticGameData.CountGameColumns];
ColAdditional = new AdditionalColumn[2];
ColDeck = new ColumnDeck();
// initialize every column
for (int index = 0; index < ColResult.Length; index++)
{
ColResult[index] = new ColumnResult();
}
for (int index = 0; index < ColGame.Length; index++)
{
ColGame[index] = new ColumnGame(index);
}
ColAdditional[Constants.iColKing] = new AdditionalColumn(CrazyFord.Data.Name.King);
ColAdditional[Constants.iColJoker] = new AdditionalColumn(CrazyFord.Data.Name.Joker);
}
private void InitializeColumns(ColumnBase.ChangeColumnDelegate alignDeckSequence)
{
for (int index = 0; index < ColResult.Length; index++)
{
ColResult[index] = new ColumnResult();
ColResult[index].AfterAddCardEvent += AlignOnZindex;
}
for (int index = 0; index < ColGame.Length; index++)
{
ColGame[index] = new ColumnGame(index);
ColGame[index].AfterAddCardEvent += AlignOnZindex;
}
ColAdditional[GameWindowConstants.iColKing] = new AdditionalColumn(CrazyFord.Data.Name.King);
ColAdditional[GameWindowConstants.iColKing].AfterAddCardEvent += AlignOnZindex;
ColAdditional[GameWindowConstants.iColJoker] = new AdditionalColumn(CrazyFord.Data.Name.Joker);
ColAdditional[GameWindowConstants.iColJoker].AfterAddCardEvent += AlignOnZindex;
ColDeck.AfterAddCardEvent += AlignOnZindex;
ColDeck.AfterAddCardEvent += alignDeckSequence;
ColDeck.AfterDeleteCardEvent += alignDeckSequence;
}
private void WriteHeights(string file, int w, int h)
{
byte[] hd = new byte[w * h * 17 + 8];
int i = 0;
BitConverter.GetBytes(w).CopyTo(hd, i); i += 4;
BitConverter.GetBytes(h).CopyTo(hd, i); i += 4;
Vector3I loc = Vector3I.Zero;
LEVGR vgr = new LEVGR();
for (loc.Z = 0; loc.Z < h; loc.Z++)
{
for (loc.X = 0; loc.X < w; loc.X++)
{
ColumnResult cr = MapParser.GetColumn(state.World, loc.X, loc.Z, w, h, vgr);
BitConverter.GetBytes(cr.Height.XNZN).CopyTo(hd, i); i += 4;
BitConverter.GetBytes(cr.Height.XPZN).CopyTo(hd, i); i += 4;
BitConverter.GetBytes(cr.Height.XNZP).CopyTo(hd, i); i += 4;
BitConverter.GetBytes(cr.Height.XPZP).CopyTo(hd, i); i += 4;
hd[i++] = cr.Walls;
}
}
using (MemoryStream ms = new MemoryStream()) {
var gs = new GZipStream(ms, CompressionMode.Compress, true);
gs.Write(hd, 0, hd.Length);
gs.Close();
ms.Position = 0;
using (var s = File.Create(file)) {
var bw = new BinaryWriter(s);
bw.Write(hd.Length);
bw.Flush();
ms.CopyTo(s);
s.Flush();
}
}
}
public GPU_ColumnBuilder(ColumnResult result, ISampler sampler)
{
Result = result;
Sampler = (GPU_TerrainSampler)sampler;
}
internal ReadOnlyCollection <ColumnResult> GetColumnResults(out bool hasTextContent)
{
List <ColumnResult> columnResults = new List <ColumnResult>(0);
Vector contentOffset = new Vector();
// hasTextContent is set to true if any of the columns has text content, not just attached objects. A column has text content if any of
// it's paragraph results has text content
hasTextContent = false;
// Query subpage details
PTS.FSSUBPAGEDETAILS subpageDetails;
PTS.Validate(PTS.FsQuerySubpageDetails(PtsContext.Context, _paraHandle.Value, out subpageDetails));
// Subpage content may be simple or complex -
// depending of set of features used in the content of the page.
// (1) simple subpage (contains only one track)
// (2) complex subpage (contains columns)
if (PTS.ToBoolean(subpageDetails.fSimple))
{
// (1) simple subpage (contains only one track)
PTS.FSTRACKDETAILS trackDetails;
PTS.Validate(PTS.FsQueryTrackDetails(PtsContext.Context, subpageDetails.u.simple.trackdescr.pfstrack, out trackDetails));
if (trackDetails.cParas > 0)
{
columnResults = new List <ColumnResult>(1);
ColumnResult columnResult = new ColumnResult(this, ref subpageDetails.u.simple.trackdescr, contentOffset);
columnResults.Add(columnResult);
if (columnResult.HasTextContent)
{
hasTextContent = true;
}
}
}
else
{
// (2) complex page (contains columns)
// cBasicColumns == 0, means that subpage content is empty
if (subpageDetails.u.complex.cBasicColumns != 0)
{
// Retrieve description for each column.
PTS.FSTRACKDESCRIPTION[] arrayColumnDesc;
PtsHelper.TrackListFromSubpage(PtsContext, _paraHandle.Value, ref subpageDetails, out arrayColumnDesc);
// Floaters are held at one column; just add the first one
columnResults = new List <ColumnResult>(1);
PTS.FSTRACKDETAILS trackDetails;
PTS.Validate(PTS.FsQueryTrackDetails(PtsContext.Context, arrayColumnDesc[0].pfstrack, out trackDetails));
if (trackDetails.cParas > 0)
{
ColumnResult columnResult = new ColumnResult(this, ref arrayColumnDesc[0], contentOffset);
columnResults.Add(columnResult);
if (columnResult.HasTextContent)
{
hasTextContent = true;
}
}
}
}
return(new ReadOnlyCollection <ColumnResult>(columnResults));
}
public StandardColumnBuilder()
{
Result = new ColumnResult();
}
public StandardColumnBuilder(ColumnResult result, ISampler sampler)
{
Result = result;
Sampler = sampler;
}
public StandardColumnBuilder(ISampler sampler)
{
Result = new ColumnResult();
Sampler = sampler;
}
public StandardColumnBuilder(ColumnResult result)
{
Result = result;
}
public GPU_ColumnBuilder(ISampler sampler)
{
Result = new ColumnResult();
Sampler = (GPU_TerrainSampler)sampler;
}
public GPU_ColumnBuilder(ColumnResult result)
{
Result = result;
}
public GPU_ColumnBuilder()
{
Result = new ColumnResult();
}