void AttachItem(int itemID)
{
Body body = UToolS.SelectBody();
if (body != null)
{
var partlist = Creation.ReadShipObject(body.gameObject); OpShip.OSIDE seldir;
var selpart = OpShip.GetInsertParent(partlist, itemID, out seldir);
TablePart newpart = OpShip.NewInsertItem(selpart, seldir, itemID);
Item item = Creation.MakeItemObject(newpart, body.transform);
item.renderer.material = MainRenderer.GetMeterial(item.gameObject, body.tone);
if (newpart.posx != 0)
{
TablePart newpair = newpart;
newpair.posx = -newpart.posx;
newpair.flip = (byte)(newpart.flip == 1 ? 0 : 1);
if (newpart.angle == 90 || newpart.angle == -90 || newpart.angle == 270)
{
newpair.angle = IMath.GetCenterDegree(newpart.angle + 180);
}
Item itemPair = Creation.MakeItemObject(newpair, body.transform);
itemPair.renderer.material = MainRenderer.GetMeterial(itemPair.gameObject, body.tone);
}
Creation.DepthSort(body.transform);
}
}
private void Update_Movement(Beatmap.Stage linkedStage, Beatmap.Track trackData)
{
var(zoneMin, zoneMax, zoneSize, _) = ZoneMinMax;
float trackWidth = GetTrackWidth(trackData);
float stageWidth = Stage.GetStageWidth(linkedStage);
float stageHeight = Stage.GetStageHeight(linkedStage);
float stagePivotY = Stage.GetStagePivotY(linkedStage);
float stageRotZ = Stage.GetStageWorldRotationZ(linkedStage);
var stagePos = Stage.GetStagePosition(linkedStage, trackData.StageIndex);
float rotX = GetTrackAngle(trackData);
float trackX = GetTrackX(trackData);
var pos = Stage.LocalToZone(trackX, 0f, 0f, stagePos, stageWidth, stageHeight, stagePivotY, stageRotZ);
// Movement
transform.position = Util.Vector3Lerp3(zoneMin, zoneMax, pos.x, pos.y);
transform.localRotation = Quaternion.Euler(0f, 0f, stageRotZ) * Quaternion.Euler(rotX, 0, 0);
ColSize = MainRenderer.transform.localScale = m_TrackTintRenderer.transform.localScale = new Vector3(
zoneSize * trackWidth * stageWidth,
zoneSize * stageHeight,
1f
);
// Tray
if (trackData.HasTray)
{
var traySize = GetRectSize(SkinType.Tray, trackData.ItemType, false, false);
var judgeLineSize = GetRectSize(SkinType.JudgeLine, trackData.ItemType);
var trayPos = LocalToZone(
TrayX, judgeLineSize.y / 2f / stageHeight, 0f,
stagePos, stageWidth, stageHeight, stagePivotY, stageRotZ,
trackX, trackWidth, rotX
);
m_TrayRenderer.transform.position = Util.Vector3Lerp3(zoneMin, zoneMax, trayPos.x, trayPos.y);
m_TrayRenderer.transform.localScale = new Vector3(traySize.x, traySize.y, 1f);
m_TrayRenderer.Scale = traySize;
}
// Renderer
MainRenderer.RendererEnable = true;
m_TrackTintRenderer.RendererEnable = true;
m_TrackTintRenderer.ItemType = trackData.ItemType;
MainRenderer.ItemType = trackData.ItemType;
m_TrayRenderer.RendererEnable = trackData.HasTray;
m_TrayRenderer.ItemType = trackData.ItemType;
MainRenderer.Duration = m_TrayRenderer.Duration = m_TrackTintRenderer.Duration = Duration;
MainRenderer.Scale = m_TrackTintRenderer.Scale = new Vector2(stageWidth * trackWidth, stageHeight);
m_TrackTintRenderer.Tint = trackData.c_Tint = GetTrackColor(trackData);
MainRenderer.Alpha = m_TrayRenderer.Alpha = Stage.GetStageAlpha(linkedStage) * GetTrackAlpha(trackData);
m_TrackTintRenderer.Alpha *= MainRenderer.Alpha;
MainRenderer.SetSortingLayer(SortingLayerID_Track, GetSortingOrder());
m_TrackTintRenderer.SetSortingLayer(SortingLayerID_TrackTint, GetSortingOrder());
m_TrayRenderer.SetSortingLayer(SortingLayerID_Tray, GetSortingOrder());
}
internal WorldRenderer(MainRenderer mainRenderer)
{
MainRenderer = mainRenderer;
Sun = new Sunlight();
Sun.Color = new Vector4(0.78f, 0.88f, 1.0f, 1.0f);
Sun.Direction = new Vector3(-0.013f, -0.125f, -0.111f);
Sun.Strength = 1.6f;
Sun.Ambient = new Vector3(0.3f, 0.3f, 0.3f);
Sun.Diffuse = new Vector3(0.5f, 0.5f, 0.5f);
Sun.Specular = new Vector3(0.1f, 0.1f, 0.1f);
}
private void Update_Movement(Beatmap.Stage stageData, int stageIndex)
{
var(zoneMin, zoneMax, zoneSize, ratio) = ZoneMinMax;
float width = GetStageWidth(stageData);
float height = GetStageHeight(stageData);
float pivotY = GetStagePivotY(stageData);
var stagePos = GetStagePosition(stageData, stageIndex);
var judgeLineSize = GetRectSize(SkinType.JudgeLine, stageData.ItemType);
var stageColor = GetStageColor(stageData);
float stageAlpha = GetStageAlpha(stageData) * stageColor.a;
var stagePosition = Util.Vector3Lerp3(zoneMin, zoneMax, stagePos.x, stagePos.y);
var stageRotation = Quaternion.Euler(0f, 0f, GetStageWorldRotationZ(stageData));
var rendererPosition = new Vector3(0f, -height * pivotY * zoneSize, 0f);
float judgeWidth = InfiniteJudgeLine ? Util.GetMaxDistanceBetweenLineAndRect(
stagePosition, stagePosition + stageRotation * Vector3.right,
zoneMin, new Vector2(zoneMax.x, zoneMin.y + zoneSize / ratio)
) * 2f : zoneSize * width;
// Movement
transform.position = stagePosition;
transform.localRotation = stageRotation;
ColSize = MainRenderer.transform.localScale = new Vector3(zoneSize * width, Mathf.Max(zoneSize * height, 0.00001f), 1f);
MainRenderer.transform.localPosition = rendererPosition;
m_JudgelineRenderer.transform.localPosition = rendererPosition;
m_JudgelineRenderer.transform.localScale = new Vector3(judgeWidth, Mathf.Max(zoneSize * judgeLineSize.y, 0.00001f), 1f);
ColPivotY = pivotY;
// Renderer
MainRenderer.RendererEnable = true;
MainRenderer.ItemType = stageData.ItemType;
MainRenderer.Scale = new Vector2(width, height);
MainRenderer.Duration = Duration;
MainRenderer.Tint = stageColor;
MainRenderer.Alpha = stageAlpha;
MainRenderer.SetSortingLayer(SortingLayerID_Stage, GetSortingOrder());
m_JudgelineRenderer.RendererEnable = true;
m_JudgelineRenderer.ItemType = stageData.ItemType;
m_JudgelineRenderer.Tint = stageColor;
m_JudgelineRenderer.Alpha = stageAlpha;
m_JudgelineRenderer.Duration = Duration;
m_JudgelineRenderer.Scale = new Vector2(judgeWidth, judgeLineSize.y);
m_JudgelineRenderer.SetSortingLayer(SortingLayerID_Judge, GetSortingOrder());
}
protected override void OnDelete()
{
MainRenderer?.Delete();
MainRenderer = null;
SkyWobjet?.Delete();
SkyWobjet = null;
SunWobject?.Delete();
SunWobject = null;
MoonWobject?.Delete();
MoonWobject = null;
Camera?.Delete();
Camera = null;
Instance = null;
base.OnDelete();
}
public void Initialize(MainRenderer mainRenderer, PlayerRenderer player1Renderer, PlayerRenderer player2Renderer, IPlayer player1, IPlayer player2)
{
this.StopGame();
this.mainRenderer = mainRenderer;
this.player1Renderer = player1Renderer;
this.player2Renderer = player2Renderer;
var gameContext = new GameContext()
{
CurrentPlayer = (new Random()).Next(2),
Players = new IPlayer[2] {
player1, player2
},
Score = new int[2],
ExceptionCount = new int[2],
ChickenCount = new int[2],
WinFlag = new bool[2],
OriginField = MapHelper.SetNumbers(MapHelper.SetMines(MapHelper.CreateFields())),
PlayField = MapHelper.CreateFields()
};
this.startGame(gameContext);
}
internal GUIRenderer(MainRenderer mainRenderer)
{
MainRenderer = mainRenderer;
}
private void Update_Movement(Beatmap.Note noteData, bool tap, SkinType lumType)
{
// Life Time
float noteEndTime = Time + noteData.Duration;
MainRenderer.Duration = Duration;
MainRenderer.LifeTime = MusicTime < noteEndTime ? MusicTime - noteData.Time : MusicTime - noteEndTime;
MainRenderer.RendererEnable = true;
// Get/Check Linked Track/Stage
MainRenderer.RendererEnable = false;
var linkedTrack = Beatmap.Tracks[noteData.TrackIndex];
if (linkedTrack is null || !linkedTrack._Active)
{
return;
}
var linkedStage = Beatmap.Stages[linkedTrack.StageIndex];
if (linkedStage is null || !linkedStage._Active)
{
return;
}
Time = noteData.Time;
var judgeLineSize = GetRectSize(SkinType.JudgeLine, 0);
var stagePos = Stage.GetStagePosition(linkedStage, linkedTrack.StageIndex);
float stageWidth = Stage.GetStageWidth(linkedStage);
float stagePivotY = Stage.GetStagePivotY(linkedStage);
float stageHeight = Stage.GetStageHeight(linkedStage);
float stageRotZ = Stage.GetStageWorldRotationZ(linkedStage);
float trackX = Track.GetTrackX(linkedTrack);
float trackWidth = Track.GetTrackWidth(linkedTrack);
float trackRotX = Track.GetTrackAngle(linkedTrack);
var(zoneMin, zoneMax, zoneSize, _) = ZoneMinMax;
var pos = Track.LocalToZone(
noteData.X, stageHeight > 0f ? judgeLineSize.y / 2f / stageHeight : 0f, Note.GetNoteZ(noteData),
stagePos, stageWidth, stageHeight, stagePivotY, stageRotZ,
trackX, trackWidth, trackRotX
);
var noteWorldPos = Util.Vector3Lerp3(zoneMin, zoneMax, pos.x, pos.y, pos.z);
// Movement
var noteSize = GetRectSize(SkinType.Note, noteData.ItemType);
var lumSize = GetRectSize(lumType, 0, true, true);
float scaleX, scaleY;
if (lumSize.x < 0f)
{
// Scaled
scaleX = (noteSize.x < 0f ? stageWidth * trackWidth * noteData.Width : noteSize.x) + LuminousAppend.x;
}
else
{
// Fixed
scaleX = lumSize.x + LuminousAppend.x;
}
if (lumSize.y < 0f)
{
// Scaled
scaleY = (tap ? LumHeight_Tap : LumHeight_Hold) + LuminousAppend.y;
}
else
{
// Fixed
scaleY = lumSize.y + LuminousAppend.y;
}
transform.position = noteWorldPos;
MainRenderer.transform.rotation = Quaternion.Euler(0f, 0f, stageRotZ);
MainRenderer.transform.localScale = new Vector3(
zoneSize * scaleX,
zoneSize * scaleY,
1f
);
// Renderer
MainRenderer.RendererEnable = true;
MainRenderer.Loop = lumType == SkinType.NoteLuminous ? 1 : 2;
MainRenderer.Scale = new Vector2(scaleX, scaleY);
MainRenderer.SetSortingLayer(SortingLayerID_Lum, GetSortingOrder());
}
public void SetHolographicSpace(HolographicSpace holographicSpace)
{
this.holographicSpace = holographicSpace;
//
// TODO: Add code here to initialize your content.
//
#if DRAW_SAMPLE_CONTENT
// Initialize the sample hologram.
spinningCubeRenderer = new SpinningCubeRenderer(deviceResources);
physicalCamera = new PhysicalCamera(deviceResources.D3DDevice, false);
physicalCamera.Initialize();
// cameraTestRenderer = new CameraTestRenderer(deviceResources, physicalCamera);
// meshTestRenderer = new MeshTestRenderer(deviceResources, physicalCamera);
meshCollectionTexturer = new MainRenderer(deviceResources, physicalCamera);
spatialInputHandler = new SpatialInputHandler();
#endif
// Use the default SpatialLocator to track the motion of the device.
locator = SpatialLocator.GetDefault();
// Be able to respond to changes in the positional tracking state.
locator.LocatabilityChanged += OnLocatabilityChanged;
// Respond to camera added events by creating any resources that are specific
// to that camera, such as the back buffer render target view.
// When we add an event handler for CameraAdded, the API layer will avoid putting
// the new camera in new HolographicFrames until we complete the deferral we created
// for that handler, or return from the handler without creating a deferral. This
// allows the app to take more than one frame to finish creating resources and
// loading assets for the new holographic camera.
// This function should be registered before the app creates any HolographicFrames.
holographicSpace.CameraAdded += OnCameraAdded;
// Respond to camera removed events by releasing resources that were created for that
// camera.
// When the app receives a CameraRemoved event, it releases all references to the back
// buffer right away. This includes render target views, Direct2D target bitmaps, and so on.
// The app must also ensure that the back buffer is not attached as a render target, as
// shown in DeviceResources.ReleaseResourcesForBackBuffer.
holographicSpace.CameraRemoved += OnCameraRemoved;
// The simplest way to render world-locked holograms is to create a stationary reference frame
// when the app is launched. This is roughly analogous to creating a "world" coordinate system
// with the origin placed at the device's position as the app is launched.
referenceFrame = locator.CreateStationaryFrameOfReferenceAtCurrentLocation();
//meshTestRenderer.Initialize(referenceFrame.CoordinateSystem);
meshCollectionTexturer.Initialize(referenceFrame.CoordinateSystem);
// Notes on spatial tracking APIs:
// * Stationary reference frames are designed to provide a best-fit position relative to the
// overall space. Individual positions within that reference frame are allowed to drift slightly
// as the device learns more about the environment.
// * When precise placement of individual holograms is required, a SpatialAnchor should be used to
// anchor the individual hologram to a position in the real world - for example, a point the user
// indicates to be of special interest. Anchor positions do not drift, but can be corrected; the
// anchor will use the corrected position starting in the next frame after the correction has
// occurred.
}
public GameManager(MainRenderer renderer)
{
this.renderer = renderer;
this.playFlag = false;
}
protected override void OnLoad()
{
Directory.CreateDirectory("fantasia");
Logger.Init();
Bind.KeyboardState = KeyboardState;
VSync = VSyncMode.Off;
_renderer = new MainRenderer(Size.X, Size.Y);
RenderFrequency = _framesPerSec;
UpdateFrequency = _ticksPerSec;
try
{
//Steamworks.SteamClient.Init(1363820);
}
catch (Exception e)
{
Logger.LogError(e);
_quit = true;
}
Block.RegisterBlocks();
AddonSystem.Init();
AddonSystem.LoadAddonBlocks();
_renderer.State = RendererState.InGame;
Panel pan = new Panel(.5, .5);
pan.Width = .1;
pan.Height = .1;
_renderer.GUIRenderer.GUIElements.Add(pan);
//List<string> files = Directory.GetFiles("fantasia/textures/", "*.png", SearchOption.AllDirectories).ToList();
//files.AddRange(Directory.GetFiles("fantasia/addons/Minecraft/textures/", "*.png", SearchOption.AllDirectories).ToList());
//AtlasCreator.GenAtlas(files.ToList());
AtlasCreator.GetTexturesAndGenAtlas();
_renderer.WorldRenderer.BlockAtlas = Texture.LoadAtlas();
GL.Enable(EnableCap.CullFace);
GL.CullFace(CullFaceMode.Back);
GL.Enable(EnableCap.DepthTest);
GL.ClearColor(.702f, .827f, .871f, 1.0f);
LocalPlayer = new LocalPlayer();
//Test Server
_server = new IntegratedServer(1, LocalPlayer);
//Set Active World
_renderer.WorldRenderer.ActiveWorld = _server.World;
Bind.TryBindKey(Keys.W, "forward");
Bind.TryBindKey(Keys.S, "backward");
Bind.TryBindKey(Keys.A, "left");
Bind.TryBindKey(Keys.D, "right");
Bind.TryBindKey(Keys.Space, "jump");
CursorGrabbed = true;
base.OnLoad();
}
private void Update_Movement(Beatmap.Stage linkedStage, Beatmap.Track linkedTrack, Beatmap.Note noteData, Beatmap.Note linkedNote)
{
var stagePos = Stage.GetStagePosition(linkedStage, linkedTrack.StageIndex);
float stageWidth = Stage.GetStageWidth(linkedStage);
float stagePivotY = Stage.GetStagePivotY(linkedStage);
float stageHeight = Stage.GetStageHeight(linkedStage);
float stageRotZ = Stage.GetStageWorldRotationZ(linkedStage);
float trackX = Track.GetTrackX(linkedTrack);
float trackWidth = Track.GetTrackWidth(linkedTrack);
float trackAngle = Track.GetTrackAngle(linkedTrack);
float gameOffset = GetGameDropOffset(noteData.TimingID, noteData._SpeedMuti);
float noteY01 = MusicTime < Time ? (noteData._NoteDropStart - gameOffset) : 0f;
float noteSizeY = noteData._NoteDropEnd - gameOffset - noteY01;
var(zoneMin, zoneMax, zoneSize, _) = ZoneMinMax;
bool isLink = linkedNote != null;
bool activeSelf = GetNoteActive(noteData, null, noteData._AppearTime);
float alpha = Stage.GetStageAlpha(linkedStage) * Track.GetTrackAlpha(linkedTrack) * Mathf.Clamp01(16f - noteY01 * 16f);
bool highlighing = MusicTime > Time && MusicTime < Time + Duration;
float noteZ = GetNoteZ(noteData);
var tint = highlighing ? HighlightTints[(int)SkinType.Note] : WHITE_32;
if (TintNote)
{
tint *= linkedTrack.c_Tint;
}
// Movement
var noteZonePos = Track.LocalToZone(
noteData.X, noteY01, noteZ,
stagePos, stageWidth, stageHeight, stagePivotY, stageRotZ,
trackX, trackWidth, trackAngle
);
var noteRot = Quaternion.Euler(0f, 0f, stageRotZ) * Quaternion.Euler(trackAngle, 0f, 0f);
var noteWorldPos = Util.Vector3Lerp3(zoneMin, zoneMax, noteZonePos.x, noteZonePos.y, noteZonePos.z);
// Size
var noteSize = GetRectSize(SkinType.Note, noteData.ItemType);
float minHeight = GetMinHeight(SkinType.Note, noteData.ItemType);
float noteScaleX = noteSize.x < 0f ? stageWidth * trackWidth * noteData.Width : noteSize.x;
float noteScaleY_scaler = Mathf.Max(noteSizeY * stageHeight, minHeight);
float noteScaleY = Mathf.Max(noteSizeY * stageHeight + minHeight, 0f);
Vector3 zoneNoteScale = new Vector3(
zoneSize * noteScaleX,
zoneSize * noteScaleY,
1f
);
Vector3 zoneNoteScale_scaler = new Vector3(
zoneSize * noteScaleX,
zoneSize * noteScaleY_scaler,
1f
);
// Transform
transform.position = Late_NoteWorldPos = noteWorldPos;
ColRot = MainRenderer.transform.rotation = noteRot;
ColSize = MainRenderer.transform.localScale = zoneNoteScale;
m_Scaler.localScale = zoneNoteScale_scaler;
m_Scaler.rotation = noteRot;
// Renderer
MainRenderer.RendererEnable = !isLink || activeSelf;
MainRenderer.ItemType = noteData.ItemType;
MainRenderer.Tint = tint;
MainRenderer.Alpha = alpha;
MainRenderer.Duration = Duration;
MainRenderer.Scale = new Vector2(noteScaleX, noteScaleY);
MainRenderer.SetSortingLayer(
Duration <= FLOAT_GAP ? SortingLayerID_Note : SortingLayerID_Note_Hold,
GetSortingOrder()
);
}
