public static MateriaisUtils getMatsPed(int _ped)
{
MateriaisUtils mats = new MateriaisUtils();
using (SqlConnection cnn = new SqlConnection(ConfigurationManager.ConnectionStrings["SqlConn"].ToString()))
{
SqlCommand cmm = cnn.CreateCommand();
cmm.CommandText = "SELECT Materiais_Pedido.Cod_Material, Materiais.Descricao, Materiais_Pedido.Qtd "
+ "FROM Materiais_Pedido INNER JOIN Materiais ON "
+ "Materiais_Pedido.Cod_Material = Materiais.Cod_Material "
+ "WHERE (Materiais_Pedido.Num_Pedido = @numped) order by Materiais.Descricao ";
cmm.Parameters.Add("@numped", SqlDbType.Int).Value = _ped;
try
{
cnn.Open();
SqlDataReader dr = cmm.ExecuteReader();
MaterialUtil mat;
while (dr.Read())
{
mat = new MaterialUtil();
mat.Cod = dr.GetInt32(0);
mat.Descr = dr.GetString(1);
mat.Qtd = dr.GetInt32(2);
mat.Descr = mat.Descr + " - Qtd: " + mat.Qtd.ToString();
mats.Items.Add(mat.Cod, mat);
}
}
catch
{
}
}
return(mats);
}
/// <summary>
/// 从数据库储存数据加载building
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public static Building Create(BuildingSaveData data)
{
Model model = LocalAssetUtil.GetModel(data.ModelDataId);
if (model == null)
{
return(null);
}
GameObject obj = CreateGameObjcet(model, data.Name);
((TransformGroup)data.TransformGroupSaveData).Inject(obj.transform);
Building building = AddComponentBuilding(obj.transform, model);
if (data.MaterialColorSaveData != null)
{
Material material = MaterialUtil.Create();
material.color = (Color)data.MaterialColorSaveData;
building.Material = material;
}
#region animation
building.isAnimOn = data.IsAnimOn;
building.appearanceAnimDatas = AnimDataUtil.Parse(data.AppearanceAnimDataSaveDatas);
building.normalAnimDatas = AnimDataUtil.Parse(data.NormalAnimDataSaveDatas);
#endregion
return(building);
}
virtual protected void make_materials()
{
float fAlpha = 0.5f;
srcMaterial = MaterialUtil.CreateTransparentMaterial(ColorUtil.CgRed, fAlpha);
srcHoverMaterial = MaterialUtil.CreateStandardMaterial(ColorUtil.CgRed);
}
/// <summary>
/// Set up materials and gizmos
/// </summary>
public static void InitializeF3Scene(FContext context)
{
// initialize materials and selection-materials
context.Scene.DisableSelectionMaterial = false;
context.Scene.SelectedMaterial = MaterialUtil.CreateStandardVertexColorMaterialF(Colorf.VideoYellow);
context.Scene.PerTypeSelectionMaterial.Add(
BodyModelSOTypes.Scan, MaterialUtil.ToUnityMaterial(OrthogenMaterials.ScanMaterial));
context.Scene.PerTypeSelectionMaterial.Add(
BodyModelSOTypes.Leg, MaterialUtil.ToUnityMaterial(OrthogenMaterials.LegMaterial));
fMaterial selectedCurveMat = MaterialUtil.CreateFlatMaterialF(Colorf.Gold, 1);
context.Scene.PerTypeSelectionMaterial.Add(BodyModelSOTypes.PlaneIntersectionCurve, selectedCurveMat);
context.Scene.PerTypeSelectionMaterial.Add(BodyModelSOTypes.TrimLoop, selectedCurveMat);
context.Scene.PerTypeSelectionMaterial.Add(BodyModelSOTypes.EnclosedPatch, selectedCurveMat);
// if you had other gizmos, you would register them here
//context.TransformManager.RegisterGizmoType("snap_drag", new SnapDragGizmoBuilder());
//controller.TransformManager.SetActiveGizmoType("snap_drag");
context.TransformManager.RegisterGizmoType(AxisTransformGizmo.DefaultName, new AxisTransformGizmoBuilder());
context.TransformManager.RegisterGizmoType(LenthenMovePivotGizmoType, new MoveLengthenPivotGizmoBuilder()
{
WidgetScale = 0.5f * Vector3f.One
});
context.TransformManager.SetActiveGizmoType(TransformManager.NoGizmoType);
BodyModelSOTypes.RegisterSocketGenTypes(context.Scene.TypeRegistry);
}
virtual public void Setup()
{
// push history stream, so that we can do undo/redo internal to tool,
// that will not end up in external history
push_history_stream();
brushIndicator = new BrushCursorSphere()
{
PositionF = () => { return(Scene.ToWorldP(lastBrushPosS.Origin)); },
Radius = fDimension.World(() => { return(radius.WorldValue); })
};
Indicators.AddIndicator(brushIndicator);
brushIndicator.material = MaterialUtil.CreateTransparentMaterialF(Colorf.DarkRed, 0.8f);
if (PreviewMaterial == null)
{
PreviewMaterial = SOMaterial.CreateFlatShaded("MeshEditor_generated", Colorf.DimGrey);
}
previewSO = new DMeshSO();
previewSO.EnableSpatial = false;
previewSO.Create(new DMesh3(Target.Mesh), PreviewMaterial);
previewSO.Name = "MeshEditorTool_preview";
previewSO.SetLocalFrame(Target.GetLocalFrame(CoordSpace.ObjectCoords), CoordSpace.ObjectCoords);
previewSO.SetLocalScale(Target.GetLocalScale());
Scene.AddSceneObject(previewSO);
PreviewSpatial = new EditMeshSpatial()
{
SourceMesh = Target.Mesh,
SourceSpatial = Target.Spatial,
EditMesh = PreviewMesh
};
}
override protected void BuildGizmo()
{
gizmo.SetName("SnapDragGizmo");
float fAlpha = 0.5f;
srcMaterial = MaterialUtil.CreateTransparentMaterial(ColorUtil.SelectionGold, fAlpha);
srcHoverMaterial = MaterialUtil.CreateStandardMaterial(ColorUtil.SelectionGold);
// generate snap target set
Snaps = SnapSet.CreateStandard(Scene);
Snaps.IgnoreSet.AddRange(this.targets);
Snaps.PreRender(parentScene.ActiveCamera.GetPosition());
// [TODO] this should iterate through targets...
Debug.Assert(this.targets.Count == 1);
// [TODO] should maybe be using GetBoundingBox now??
Bounds b = this.targets[0].GetLocalBoundingBox();
float h = b.extents[1];
// object origin
add_snap_source(Vector3.zero, "obj_origin", Snaps);
add_snap_source(Vector3.zero + h * Vector3.up, "obj_top", Snaps);
add_snap_source(Vector3.zero - h * Vector3.up, "obj_base", Snaps);
gizmo.Hide();
}
// creates a button in the desired geometry shape
public void Create(SmoothCockpitTracker tracker, Cockpit cockpit)
{
this.tracker = tracker;
this.cockpit = cockpit;
fGameObject cockpitGO = cockpit.RootGameObject;
Frame3f cockpitF = cockpitGO.GetWorldFrame();
matFixed = MaterialUtil.CreateStandardMaterialF(ColorUtil.ForestGreen);
matTracking = MaterialUtil.CreateStandardMaterialF(ColorUtil.SelectionGold);
matHover = MaterialUtil.CreateStandardMaterialF(ColorUtil.Lighten(ColorUtil.ForestGreen, 0.1f));
matLocked = MaterialUtil.CreateStandardMaterialF(ColorUtil.CgRed);
matLockedHover = MaterialUtil.CreateStandardMaterialF(ColorUtil.Lighten(ColorUtil.CgRed, 0.1f));
indicator = UnityUtil.CreatePrimitiveGO("tracking_indicator", UnityEngine.PrimitiveType.Capsule, matFixed, true);
MaterialUtil.DisableShadows(indicator);
UnityUtil.SetLayerRecursive(indicator, FPlatform.HUDLayer);
indicator.SetLocalScale(0.025f * Vector3f.One);
indicator.RotateD(Vector3f.AxisZ, 90.0f);
Vector3f vDir = (1.0f * cockpitF.Z - 1.0f * cockpitF.Y).Normalized;
indicator.SetPosition(cockpitF.Origin + IndicatorDistance * vDir);
AppendExistingGO(indicator);
//indicator.transform.SetParent(cockpit.RootGameObject.transform, true);
}
protected override void BuildGizmo()
{
gizmo.SetName("EditPrimitiveGizmo");
float fAlpha = 0.5f;
stdMaterial = MaterialUtil.CreateTransparentMaterial(Color.yellow, fAlpha);
stdHoverMaterial = MaterialUtil.CreateStandardMaterial(Color.yellow);
// [TODO] this should iterate through targets... ??
Debug.Assert(this.targets.Count == 1);
PolyCurveSO target = this.targets[0] as PolyCurveSO;
target.OnCurveModified += on_curve_modified;
add_curve_widget(target, true,
() => { return((Vector3)target.Curve.Start); });
add_curve_widget(target, false,
() => { return((Vector3)target.Curve.End); });
gizmo.Hide();
}
private void SetGhostColor()
{
var curColor = PlayerColor.Value;
curColor.a = 0.05f;
PlayerColor.Value = curColor;
MaterialUtil.SetBlend(MaterialBlendMode.Fade, _material);
}
private void ClearGhostColor()
{
var curColor = PlayerColor.Value;
curColor.a = 1f;
PlayerColor.Value = curColor;
MaterialUtil.SetBlend(MaterialBlendMode.Opaque, _material);
}
public override PolyCurveSO Create(SOMaterial defaultMaterial)
{
EnclosedPatchSO so = (EnclosedPatchSO)base.Create(defaultMaterial);
previewMaterial = MaterialUtil.CreateTransparentMaterialF(Colorf.ForestGreen, 0.1f);
return(so);
}
fPolylineGameObject allocate_polyline_go()
{
fPolylineGameObject go = GameObjectFactory.CreatePolylineGO(
"gcode_path", new List <Vector3f>(), CCMaterials.PathMaterial_Default, true, 1.0f, LineWidthType.World);
go.SetCornerQuality(fCurveGameObject.CornerQuality.Minimal);
MaterialUtil.DisableShadows(go);
return(go);
}
public ToolpathDeviationViz(ToolpathSO so)
{
SO = so;
//SO.OnMeshModified += OnInputModified;
HighDeviationMaterial = MaterialUtil.CreateTransparentMaterialF(Colorf.VideoRed);
MedDeviationMaterial = MaterialUtil.CreateTransparentMaterialF(Colorf.Orange);
LowDeviationMaterial = MaterialUtil.CreateTransparentMaterialF(Colorf.Yellow);
}
public void BeginSetWorldScale(Frame3f center, Frame3f plane, float minr)
{
deadzone_r = minr;
hitFrame = plane;
mYes = MaterialUtil.CreateTransparentMaterial(ColorUtil.PivotYellow, 0.5f);
mNo = MaterialUtil.CreateTransparentMaterial(ColorUtil.MiddleGrey, 0.3f);
go = UnityUtil.CreatePrimitiveGO("worldscale_ball", PrimitiveType.Sphere, mNo);
UnityUtil.SetGameObjectFrame(go, center, CoordSpace.WorldCoords);
}
override protected void BuildGizmo()
{
gizmo.SetName("EditPrimitiveGizmo");
float fAlpha = 0.5f;
stdMaterial = MaterialUtil.CreateTransparentMaterial(Color.yellow, fAlpha);
stdHoverMaterial = MaterialUtil.CreateStandardMaterial(Color.yellow);
// [TODO] this should iterate through targets... ??
Debug.Assert(this.targets.Count == 1);
// object origin
foreach (var so in Targets)
{
if ((so is PrimitiveSO) == false)
{
continue;
}
PrimitiveSO pso = so as PrimitiveSO;
pso.Parameters.OnParameterModified += on_parameter_modified;
float fVertMult = 1.0f;
float fHorzMult = 1.0f;
if (pso.Center == CenterModes.Base)
{
fHorzMult = 2.0f;
}
if (pso is CylinderSO)
{
add_axis_widget(pso, Vector3.up, fVertMult, "scaled_height",
() => { return(pso.Parameters.GetValueFloat("scaled_height") * 0.5f * Vector3.up); });
add_axis_widget(pso, Vector3.right, 1.0f, "scaled_radius",
() => { return(pso.Parameters.GetValueFloat("scaled_radius") * Vector3.right); });
}
else if (pso is SphereSO)
{
add_axis_widget(pso, Vector3.up, 1.0f, "scaled_diameter",
() => { return(pso.Parameters.GetValueFloat("scaled_diameter") * 0.5f * Vector3.up); });
}
else if (pso is BoxSO)
{
add_axis_widget(pso, Vector3.up, fVertMult, "scaled_height",
() => { return(pso.Parameters.GetValueFloat("scaled_height") * 0.5f * Vector3.up); });
add_axis_widget(pso, Vector3.right, fHorzMult, "scaled_width",
() => { return(pso.Parameters.GetValueFloat("scaled_width") * 0.5f * Vector3.right); });
add_axis_widget(pso, Vector3.forward, fHorzMult, "scaled_depth",
() => { return(pso.Parameters.GetValueFloat("scaled_depth") * 0.5f * Vector3.forward); });
}
}
gizmo.Hide();
}
public static void InitializeMaterials()
{
PreviewTransparentMaterial = SOMaterial.CreateTransparent("preview_trans", new Colorf(Colorf.SelectionGold, 0.2f));
PathMaterial_Extrude = MaterialUtil.CreateFlatMaterial(Colorf.VideoBlack);
PathMaterial_Support = MaterialUtil.CreateFlatMaterial(Colorf.VideoMagenta);
PathMaterial_Travel = MaterialUtil.CreateFlatMaterial(Colorf.VideoGreen, 0.5f);
PathMaterial_PlaneChange = MaterialUtil.CreateFlatMaterial(Colorf.VideoBlue, 0.5f);
PathMaterial_Default = MaterialUtil.CreateFlatMaterial(Colorf.VideoRed, 0.5f);
}
public override void Open()
{
base.Open();
//change by targetBuilding
this.material = null;
ChangeData(PanelControl.current.targetBuilding.Material.color);
//init data
this.material = MaterialUtil.Create();
isFirstChange = true;
}
public void Build(Frame3f worldFrame, GameObject parent, Material mat, int nLayer = -1)
{
primGO = UnityUtil.CreatePrimitiveGO("generated_point", PrimitiveType.Sphere, mat, true);
UnityUtil.SetGameObjectFrame(primGO, worldFrame, CoordSpace.WorldCoords);
MaterialUtil.DisableShadows(primGO);
UnityUtil.AddChild(parent, primGO, true);
if (nLayer > 0)
{
primGO.SetLayer(nLayer);
}
}
public static GameObject createLayer(string shaderName, string name, Vector3 position, Transform parentT)
{
GameObject go = MeshUtil.createPlane(PropertiesSingleton.instance.width, PropertiesSingleton.instance.height, name);
go.name = name;
#if UNITY_EDITOR
go.transform.renderer.sharedMaterial = MaterialUtil.getMaterial(go.name, shaderName);
#endif
go.transform.parent = parentT;
go.transform.position = position;
return(go);
}
public virtual void Setup()
{
// turn on xform gizmo
Scene.Context.TransformManager.PushOverrideGizmoType(BendPlanePivotGizmo.DefaultTypeName);
Vector3d ctrPt = TargetSO.Mesh.CachedBounds.Center;
Frame3f nearestF = MeshQueries.NearestPointFrame(TargetSO.Mesh, TargetSO.Spatial, ctrPt, true);
BendPlaneOriginS = SceneTransforms.ObjectToSceneP(TargetSO, nearestF.Origin);
BendPlaneNormalS = Vector3d.AxisY;
bendPlaneGizmoSO = new BendPlanePivotSO();
bendPlaneGizmoSO.Create(Scene.PivotSOMaterial, Scene.FrameSOMaterial);
bendPlaneGizmoSO.OnTransformModified += OnBendPlaneTransformModified;
Scene.AddSceneObject(bendPlaneGizmoSO);
Frame3f cutFrameS = new Frame3f(BendPlaneOriginS); cutFrameS.AlignAxis(1, (Vector3f)BendPlaneNormalS);
bendPlaneGizmoSO.SetLocalFrame(cutFrameS, CoordSpace.SceneCoords);
allow_selection_changes = true;
Scene.Select(bendPlaneGizmoSO, true);
allow_selection_changes = false;
StandardIndicatorFactory factory = new StandardIndicatorFactory();
SectionPlaneIndicator bendPlane = factory.MakeSectionPlaneIndicator(
100, "bendPlane",
fDimension.Scene(100),
() => { return(new Frame3f(BendPlaneOriginS, BendPlaneNormalS)); },
() => { return(new Colorf(Colorf.LightGreen, 0.5f)); },
() => { return(true); }
);
Indicators.AddIndicator(bendPlane);
// save initial vtx positions
VertexPositions = new Vector3d[TargetSO.Mesh.MaxVertexID];
foreach (int vid in TargetSO.Mesh.VertexIndices())
{
VertexPositions[vid] = TargetSO.Mesh.GetVertex(vid);
}
PreviewSO = TargetSO.Duplicate() as DMeshSO;
Scene.AddSceneObject(PreviewSO);
//PreviewSO.AssignSOMaterial(Scene.TransparentNewSOMaterial);
fMaterial transMat = MaterialUtil.CreateTransparentMaterial(Colorf.BlueMetal.SetAlpha(0.1f));
TargetSO.PushOverrideMaterial(transMat);
TargetSO.SetLayer(FPlatform.WidgetOverlayLayer);
}
// initializes snap set with default materials and known generators
static public SnapSet CreateStandard(FScene scene)
{
SnapSet s = new SnapSet(scene);
var genVisibleMaterial = MaterialUtil.CreateTransparentMaterial(ColorUtil.ForestGreen, 0.5f);
var genHiddenMaterial = MaterialUtil.CreateTransparentMaterial(ColorUtil.ForestGreen, 0.2f);
s.Generators.Add(
new PrimitiveSnapGenerator(genVisibleMaterial, genHiddenMaterial));
s.Generators.Add(
new CurveSnapGenerator(genVisibleMaterial, genHiddenMaterial));
return(s);
}
protected StandardSnapGenerator(Material visibleMaterial, Material hiddenMaterial)
{
this.visibleMaterial = visibleMaterial;
if (this.visibleMaterial == null)
{
this.visibleMaterial = MaterialUtil.CreateTransparentMaterial(ColorUtil.PivotYellow, 0.5f);
}
this.hiddenMaterial = hiddenMaterial;
if (this.hiddenMaterial == null)
{
this.hiddenMaterial = MaterialUtil.CreateTransparentMaterial(ColorUtil.PivotYellow, 0.3f);
}
parent = new GameObject("StandardSnapGenerator_parent");
}
public void Create(SOMaterial useMaterial, fGameObject parent)
{
if (curve == null)
{
curve = new DCurve3();
}
meshObject = GameObjectFactory.CreateMeshGO("mesh_tube_preview");
//meshObject.SetMesh(new fMesh())
meshObject.SetMaterial(MaterialUtil.ToMaterialf(useMaterial));
bUpdatePending = true;
parent.AddChild(meshObject, false);
}
public TwoPointFaceSelectionTool(FScene scene, DMeshSO target) : base(scene)
{
TargetSO = target;
indicators = new ToolIndicatorSet(this, scene);
have_source = have_extent = false;
selection_valid = false;
selectionCache = new MeshFaceSelectionCache(target.Mesh);
selectionCache.ChunkMeshMaterial = MaterialUtil.CreateStandardMaterialF(Colorf.Gold);
targetTrackingGO = GameObjectFactory.CreateTrackingGO("track_target", target.RootGameObject);
scene.TransientObjectsParent.AddChild(targetTrackingGO, false);
selectionCache.ChunkMeshParent = targetTrackingGO;
}
public override fMaterial MakeMaterial(AxisGizmoFlags widget)
{
switch (widget)
{
case AxisGizmoFlags.AxisTranslateY:
if (MyYMaterial == null)
{
MyYMaterial = MaterialUtil.CreateStandardMaterial(Colorf.VideoGreen);
}
return(MyYMaterial);
default:
return(null);
}
}
protected override fGameObject create_pivot_shape()
{
mesh_height = CC.Settings.LayerHeightMM;
TrivialBox3Generator boxgen = new TrivialBox3Generator()
{
NoSharedVertices = true,
Box = new Box3d(Vector3d.Zero, new Vector3d(2.5, CC.Settings.LayerHeightMM, 2.5))
};
DMesh3 mesh = boxgen.Generate().MakeDMesh();
fMeshGameObject meshGO = GameObjectFactory.CreateMeshGO("pivotMesh",
new fMesh(mesh), true, true);
meshGO.SetMaterial(MaterialUtil.CreateStandardMaterial(Colorf.Orange));
return(meshGO);
}
public virtual void HandleColliderInit()
{
if (!isReady)
{
return;
}
if (collider == null)
{
boxCollider = gameObject.AddComponent <BoxCollider>();
boxCollider.isTrigger = true;//gameDraggableLevelItem.gameLevelItemAsset.destructable;
boxCollider.size = boxCollider.size.WithX(4.2f).WithY(4.2f).WithZ(4.2f);
boxCollider.center = boxCollider.size.WithY(2.1f);
boxCollider.material = MaterialUtil.LoadPhysicMaterialFromResources("materials/ArcadeBounce");
}
}
//GameObject trailGO;
//TrailRenderer trailRen;
public PrintTempParticleSystem(GameObject parentGO)
{
heatParticlesGO = new GameObject("heatParticleSystem");
ps = heatParticlesGO.AddComponent <ParticleSystem>();
parentGO.AddChild(heatParticlesGO, false);
Material heatMat = MaterialUtil.SafeLoadMaterial("HeatParticleMaterial");
heatParticlesGO.GetComponent <ParticleSystemRenderer>().material =
heatMat;
//MaterialUtil.SafeLoadMaterial("Particles/Alpha Blended Premultiply");
heatParticlesGO.SetLayer(FPlatform.WidgetOverlayLayer);
heatParticlesGO.GetComponent <Renderer>().material.renderQueue = 4000;
MaterialUtil.DisableShadows(heatParticlesGO);
ps.Stop();
sparksGO = UnityUtil.FindGameObjectByName("SparksPS");
sparksGO.SetVisible(true);
sparksPS = sparksGO.GetComponent <ParticleSystem>();
sparksPS.Stop();
parentGO.AddChild(sparksGO, false);
fMaterial mat = MaterialUtil.CreateFlatMaterial(Colorf.VideoRed, 0.75f);
trailGO = GameObjectFactory.CreatePolylineGO("trail", new List <Vector3f>(), mat, true, 0.5f, LineWidthType.World);
trailGO.GetComponent <Renderer>().material.renderQueue = 3500;
trailGO.SetCornerQuality(fCurveGameObject.CornerQuality.Minimal);
trailGO.SetParent(parentGO);
trailGO.SetLayer(FPlatform.WidgetOverlayLayer);
MaterialUtil.DisableShadows(trailGO);
//trailGO = new GameObject("heatTrail");
//trailRen = trailGO.AddComponent<TrailRenderer>();
//parentGO.AddChild(trailGO, false);
//trailRen.material = MaterialUtil.CreateFlatMaterial(Colorf.VideoRed);
//trailRen.material.renderQueue = 3500;
//trailRen.minVertexDistance = 0.2f;
//trailRen.numCornerVertices = 4;
//trailRen.startWidth = 0.5f;
//trailRen.endWidth = 0.1f;
//trailRen.time = 2.0f;
}
public static void Init(ChessBoard cb)
{
MaterialUtil.SetKey(cb);
cb.KingIndex[White] = BitOperations.TrailingZeroCount(cb.Pieces[White][King]);
cb.KingIndex[Black] = BitOperations.TrailingZeroCount(cb.Pieces[Black][King]);
cb.ColorToMoveInverse = 1 - cb.ColorToMove;
cb.Pieces[White][All] = cb.Pieces[White][Pawn] | cb.Pieces[White][Bishop] | cb.Pieces[White][Knight] |
cb.Pieces[White][King] | cb.Pieces[White][Rook]
| cb.Pieces[White][Queen];
cb.Pieces[Black][All] = cb.Pieces[Black][Pawn] | cb.Pieces[Black][Bishop] | cb.Pieces[Black][Knight] |
cb.Pieces[Black][King] | cb.Pieces[Black][Rook]
| cb.Pieces[Black][Queen];
cb.AllPieces = cb.Pieces[White][All] | cb.Pieces[Black][All];
cb.EmptySpaces = ~cb.AllPieces;
Array.Fill(cb.PieceIndexes, Empty);
foreach (var t in cb.Pieces)
{
for (var pieceIndex = 1; pieceIndex < cb.Pieces[0].Length; pieceIndex++)
{
var piece = t[pieceIndex];
while (piece != 0)
{
cb.PieceIndexes[BitOperations.TrailingZeroCount(piece)] = pieceIndex;
piece &= piece - 1;
}
}
}
cb.SetCheckingPinnedAndDiscoPieces();
cb.PsqtScore = EvalUtil.CalculatePositionScores(cb);
cb.Phase = EvalUtil.PhaseTotal -
(BitOperations.PopCount((ulong)(cb.Pieces[White][Knight] | cb.Pieces[Black][Knight])) *
EvalConstants.Phase[Knight]
+ BitOperations.PopCount((ulong)(cb.Pieces[White][Bishop] | cb.Pieces[Black][Bishop])) *
EvalConstants.Phase[Bishop]
+ BitOperations.PopCount((ulong)(cb.Pieces[White][Rook] | cb.Pieces[Black][Rook])) *
EvalConstants.Phase[Rook]
+ BitOperations.PopCount((ulong)(cb.Pieces[White][Queen] | cb.Pieces[Black][Queen])) *
EvalConstants.Phase[Queen]);
Zobrist.SetPawnKey(cb);
Zobrist.SetKey(cb);
}
void compute_slice_polylines()
{
fMaterial mat1 = MaterialUtil.CreateFlatMaterialF(Colorf.Black);
fMaterial mat2 = MaterialUtil.CreateFlatMaterialF(Colorf.BlueMetal);
// [TODO] do we need to hold data_lock here? seems like no since main thread is blocked,
// then it would never be the case that we are setting SliceSet = null
// create geometry
int slice_i = 0;
SlicePolylines = new List <fPolylineGameObject>();
foreach (PlanarSlice slice in SliceSet.Slices)
{
//DebugUtil.Log(2, "Slice has {0} solids", slice.Solids.Count);
Colorf slice_color = (slice_i % 2 == 0) ? Colorf.Black : Colorf.BlueMetal;
fMaterial slice_mat = (slice_i % 2 == 0) ? mat1 : mat2;
slice_i++;
foreach (GeneralPolygon2d poly in slice.Solids)
{
List <Vector3f> polyLine = new List <Vector3f>();
for (int pi = 0; pi <= poly.Outer.VertexCount; ++pi)
{
int i = pi % poly.Outer.VertexCount;
Vector2d v2 = poly.Outer[i];
Vector2d n2 = poly.Outer.GetTangent(i).Perp;
Vector3d v3 = new Vector3d(v2.x, v2.y, slice.Z);
v3 = MeshTransforms.ConvertZUpToYUp(v3);
v3 = MeshTransforms.FlipLeftRightCoordSystems(v3);
Vector3d n3 = MeshTransforms.ConvertZUpToYUp(new Vector3d(n2.x, n2.y, 0));
n3 = MeshTransforms.FlipLeftRightCoordSystems(n3);
n3.Normalize();
v3 += 0.1f * n3;
polyLine.Add((Vector3f)v3);
}
//DebugUtil.Log(2, "Polyline has {0} vertiecs", polyLine.Count);
fPolylineGameObject go = GameObjectFactory.CreatePolylineGO(
"slice_outer", polyLine, slice_color, 0.1f, LineWidthType.World);
go.SetMaterial(slice_mat, true);
CC.ActiveScene.RootGameObject.AddChild(go, false);
SlicePolylines.Add(go);
}
}
}
