//--------------------------------------
// PUBLIC CONSTRUCTORS
//--------------------------------------
/// <summary>Initializes a new environment map.</summary>
/// <param name="renderer">The renderer to use when rendering the environment maps.</param>
/// <param name="eid">The id of the entity to which the environment map belongs.</param>
/// <param name="transf">The transform component of the entity to environment map.</param>
/// <param name="material">The effect to use as material. Normally this should be set to a cube
/// map shader.</param>
/// <param name="skybox">The skybox renderer.</param>
public EnvMapMaterial(RenderingSystem renderer,
int eid,
CTransform transf,
Effect material,
SkyBoxSystem skybox = null)
: base(material)
{
mEid = eid;
mRenderer = renderer;
mTransf = transf;
mSkybox = skybox;
var device = Game1.Inst.GraphicsDevice;
for (var i = 0; i < 6; i++)
{
mEnvRTs[i] = new RenderTarget2D(device,
512,
512,
false,
device.PresentationParameters.BackBufferFormat,
DepthFormat.None,
1,
RenderTargetUsage.PreserveContents); // TODO: Needed?
}
var bumpTex = Game1.Inst.Content.Load <Texture2D>("Textures/Bumpmap0");
mEffect.Parameters["BumpMap"].SetValue(bumpTex);
}
//--------------------------------------
// PUBLIC METHODS
//--------------------------------------
/// <summary>Initializes the scene.</summary>
public override void Init()
{
AddSystems(new LogicSystem(),
new PhysicsSystem(),
new CameraSystem(),
mSkybox = new SkyBoxSystem(),
mRenderer = new RenderingSystem());
#if DEBUG
AddSystem(new DebugOverlay());
#endif
base.Init();
InitCam();
// Spawn a few balls.
for (var i = 0; i < 10; i++)
{
CreateBall(new Vector3(0.9f * i - 3.5f, 0.3f * i, 0.0f), // Position
new Vector3(1.0f, 0.0f, 0.0f), // Velocity
1.0f); // Radius
}
mRT = GfxUtil.CreateRT();
mDistortFX = Game1.Inst.Content.Load <Effect>("Effects/Distort");
mDistortFX.Parameters["SrcTex"].SetValue(mRT);
}
/// <summary>Initializes a new environment map.</summary>
/// <param name="renderer">The renderer to use when rendering the environment maps.</param>
/// <param name="eid">The id of the entity to which the environment map belongs.</param>
/// <param name="transf">The transform component of the entity to environment map.</param>
/// <param name="skybox">The skybox renderer.</param>
public EnvMapMaterial(RenderingSystem renderer,
int eid,
CTransform transf,
SkyBoxSystem skybox = null)
: this(renderer, eid, transf, Game1.Inst.Content.Load <Effect>("Effects/CubeMap"), skybox)
{
}
/// <summary>Initializes a new environment map.</summary>
/// <param name="renderer">The renderer to use when rendering the environment maps.</param>
/// <param name="eid">The id of the entity to which the environment map belongs.</param>
/// <param name="transf">The transform component of the entity to environment map.</param>
public EnvMapMaterial(RenderingSystem renderer,
int eid,
CTransform transf,
Texture2D bumpTex = null)
: this(renderer, eid, transf, Game1.Inst.Content.Load <Effect>("Effects/CubeMap"), bumpTex)
{
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
// Create game systems
InputSystem = new InputSystem(this);
NetworkSystem = new NetworkSystem(this);
RenderingSystem = new RenderingSystem(this);
MovementSystem = new MovementSystem(this);
WeaponSystem = new WeaponSystem(this);
EnemyAISystem = new EnemyAISystem(this);
NpcAISystem = new NpcAISystem(this);
GarbagemanSystem = new GarbagemanSystem(this);
CollisionSystem = new Systems.CollisionSystem(this);
RoomChangingSystem = new RoomChangingSystem(this);
QuestLogSystem = new QuestLogSystem(this);
SpriteAnimationSystem = new SpriteAnimationSystem(this);
SkillSystem = new SkillSystem(this);
TextSystem = new TextSystem(this);
// Testing code.
LevelManager.LoadContent();
LevelManager.LoadLevel("D01F01R01");
//End Testing Code
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
// Create game systems
InputSystem = new InputSystem(this);
NetworkSystem = new NetworkSystem(this);
RenderingSystem = new RenderingSystem(this);
MovementSystem = new MovementSystem(this);
WeaponSystem = new WeaponSystem(this);
EnemyAISystem = new EnemyAISystem(this);
NpcAISystem = new NpcAISystem(this);
GarbagemanSystem = new GarbagemanSystem(this);
CollisionSystem = new Systems.CollisionSystem(this);
RoomChangingSystem = new RoomChangingSystem(this);
QuestLogSystem = new QuestLogSystem(this);
SpriteAnimationSystem = new SpriteAnimationSystem(this);
SkillSystem = new SkillSystem(this);
TextSystem = new TextSystem(this);
EngineeringOffenseSystem = new EngineeringOffenseSystem(this);
HUDSystem = new HUDSystem(this);
InputHelper.Load();
HUDSystem.LoadContent();
// Testing code.
LevelManager.LoadContent();
LevelManager.LoadLevel("D01F01R01");
//Song bg = Content.Load<Song>("Audio/Main_Loop");
//MediaPlayer.Stop();
//MediaPlayer.IsRepeating = true;
//MediaPlayer.Play(bg);
//End Testing Code
}
protected override void Initialize()
{
base.Initialize();
Tasks.TaskQueue = new ThreadPoolTaskQueue(8);
var dm = graphics.GraphicsDevice.DisplayMode;
Window.Position = new Point((dm.Width - Width) / 2, (dm.Height - Height) / 2);
renderUtil = new RenderUtil(GraphicsDevice);
renderingSystem = new RenderingSystem(Content);
entityFactory = new EntityFactory(renderingSystem, entityWorld);
inputSystem = new InputSystem(eventBus);
AddSystem(renderingSystem);
AddSystem(new VelocitySystem());
AddSystem(new CollisionSystem());
AddSystem(new CollisionResolverSystem());
AddSystem(new HudSystem());
AddSystem(new PlayerControllerSystem());
AddSystem(new BoundsSystem(Width / 2 - 250, Height / 2 - 250, 500, 500, renderUtil));
}
//--------------------------------------
// PUBLIC METHODS
//--------------------------------------
/// <summary>Initializes the scene.</summary>
public override void Init()
{
AddSystems(new LogicSystem(),
new PhysicsSystem()
{
Gravity = Vector3.Zero
},
new CameraSystem(),
mSkybox = new SkyBoxSystem(),
mRenderer = new RenderingSystem(),
new InputSystem());
#if DEBUG
AddSystem(new DebugOverlay());
#endif
base.Init();
InitCam();
// Spawn a few balls.
for (var i = 0; i < 30; i++)
{
var r = i == 0 ? 6.0f : 1.0f;
CreateBall(new Vector3(0.9f * i - 3.5f, 0.3f * i, 0.7f * i), // Position
new Vector3(0f, 0f, 0f), // Velocity
r, // Radius
i == 0); // Reflective
}
}
//--------------------------------------
// PUBLIC METHODS
//--------------------------------------
/// <summary>Initializes the scene.</summary>
public override void Init()
{
AddSystems(new LogicSystem(),
new PhysicsSystem()
{
Gravity = Vector3.Zero
},
mRenderer = new RenderingSystem());
#if DEBUG
AddSystem(new DebugOverlay());
#endif
base.Init();
mCamID = InitCam();
// Spawn a few balls.
for (var i = 0; i < 2; i++)
{
var r = i == 0 ? 6.0f : 1.0f;
CreateBall(new Vector3(0.9f * i - 3.5f, 0.3f * i, 0.7f * i), // Position
new Vector3(3.0f * (i - 4), 2.0f * i, 3.0f - i), // Velocity
r, // Radius
i == 0); // Reflective
}
}
void Setup()
{
creationSystem = new ParticleCreationSystem(world, this, ParticleMesh, ParticleMaterial);
anchorSystem = new AnchorMoveSystem(world);
moveSystem = new ParticleMoveSystem(world);
velocitySystem = new ApplyVelocitySystem(world);
transformSystem = new TransformWriteSystem(world);
renderSystem = new RenderingSystem(world);
}
private void ResetGame()
{
ComponentManager.Get().ClearComponents();
renderingSystem = new RenderingSystem();
physicsSystem = new PhysicsSystem();
collisionDetectionSystem = new CollisionDetectionSystem();
inputSystem = new InputSystem();
spawnSystem = new SpawnSystem();
textSystem = new TextSystem();
CreateEntities();
}
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
renderingSystem = new RenderingSystem();
physicsSystem = new PhysicsSystem();
collisionDetectionSystem = new CollisionDetectionSystem();
inputSystem = new InputSystem();
spawnSystem = new SpawnSystem();
textSystem = new TextSystem();
scoreSystem = new ScoreSystem();
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
// Create game systems
InputSystem = new InputSystem(this);
NetworkSystem = new NetworkSystem(this);
RenderingSystem = new RenderingSystem(this);
MovementSystem = new MovementSystem(this);
// Testing code
AggregateFactory.CreateFromAggregate(Aggregate.FairyPlayer);
}
private void Initialize()
{
audioManager = new AudioManager();
renderer = new ImmediateModeRenderer();
sprites = new List <Sprite>();
sources = new List <Source>();
entities = new List <Entity>();
string script = "";
using (StreamReader file = new StreamReader("Assets/Scripts/movement_script.lua"))
{
script = file.ReadToEnd();
}
Entity entity = new Entity(0);
entity.AddComponent(new Position(0, 0));
entity.AddComponent(new Input(new KeyboardAndMouse()));
entity.AddComponent(new Velocity(0, 0));
entity.AddComponent(new SpriteComponent(new Sprite(0, 0, 20, 20, SceneManager.AssetManager.LoadTexture("Assets/Images/heart.png"))));
entity.AddComponent(new Player());
entities.Add(entity);
for (int i = 1; i < 2000; i++)
{
entity = new Entity(i);
entity.AddComponent(new Position(i * 40, 0));
entity.AddComponent(new Velocity(0, 1));
//entity.AddComponent(new SpriteComponent(new Sprite(0, 0, 20, 20, SceneManager.AssetManager.LoadTexture("Assets/Images/heart.png"))));
entity.AddComponent(new Rain());
entities.Add(entity);
}
movementSystem = new MovementSystem();
scriptingSystem = new ScriptingSystem();
renderingSystem = new RenderingSystem(renderer);
inputSystem = new InputSystem();
collisionSystem = new CollisionSystem();
collisionHandler = new CollisionHandler();
sources.Add(new Source(SceneManager.AssetManager.LoadWave("Assets/Audio/main game.wav")));
sources[0].Play();
sources[0].SetPosition(350, 200);
sources[0].ReferenceDistance = 200f;
//sources[0].SetVelocity(0, 0);
}
public MapViewport(int width, int height) : base(GameConstants.MapWidth, GameConstants.MapHeight)
{
Engine.ActiveConsole = this;
Engine.UseMouse = true;
Engine.Keyboard.RepeatDelay = 0.07f;
Engine.Keyboard.InitialRepeatDelay = 0.1f;
TextSurface.RenderArea = new Microsoft.Xna.Framework.Rectangle(0, 0, width, height);
Fill(null, Colors.DefaultBG, null);
renderer = new RenderingSystem(this);
map = new MapSystem(GameConstants.MapWidth, GameConstants.MapHeight);
//ComponentManager.AddComponent( EntityManager.Map, map );
}
bool CreateRenderTarget()
{
DestroyRenderTarget();
if (EngineApp.Instance == null)
{
return(false);
}
Vector2I size = new Vector2I(ClientRectangle.Size.Width, ClientRectangle.Size.Height);
if (size.X < 1 || size.Y < 1)
{
return(false);
}
renderWindow = RenderingSystem.CreateRenderWindow(Handle, size);
if (renderWindow == null)
{
return(false);
}
viewport = renderWindow.AddViewport(true, true);
viewport.MousePositionSetImpl = MousePositionSet;
viewport.MouseRelativeModeSetImpl = MouseRelativeModeSet;
ViewportCreated?.Invoke(this);
//apply DpiScaleFactor to canvas default font size
var defaultSize = 0.017;
try
{
defaultSize *= DpiHelper.Default.DpiScaleFactor;
}
catch { }
viewport.CanvasRenderer.DefaultFontSize = defaultSize;
//viewport.CanvasRenderer.DefaultFontSize = 0.02 * DpiHelper.Default.DpiScaleFactor;
//var fontHeight = viewport.CanvasRenderer.DefaultFontSize * DpiHelper.Default.DpiScaleFactor;
//viewport.CanvasRenderer.DefaultFont = EngineFontManager.Instance.LoadFont( "Default", fontHeight );
//if( viewport.CanvasRenderer.DefaultFont == null )
// viewport.CanvasRenderer.DefaultFont = EngineFontManager.Instance.LoadFont( "Default", "English", fontHeight );
return(true);
}
public World(Game game, Renderer renderer)
{
this.Game = game;
this.Renderer = renderer;
Entities = new SparseArray <Entity>();
Transformations = new SparseArray <Transformation>();
Primitives = new SparseArray <Primitive>();
Newtonians = new SparseArray <Newtonian>();
Models = new SparseArray <Microsoft.Xna.Framework.Graphics.Model>();
Players = new SparseArray <Player>();
PlayerControls = new SparseArray <PlayerControl>();
newtonianSystem = new NewtonianSystem(this);
renderingSystem = new RenderingSystem(this, renderer);
networkSystem = new NetworkSystem(this);
inputSystem = new InputManager(this);
}
static void Main(string[] args)
{
var resourcesSystem = new ResourcesSystem();
var renderingSystem = new RenderingSystem();
var inputSystem = new InputSystem();
var timeSystem = new TimeSystem();
resourcesSystem.Setup();
timeSystem.Setup();
inputSystem.Setup();
renderingSystem.Setup(inputSystem, resourcesSystem);
while (true)
{
timeSystem.Update();
renderingSystem.Update();
inputSystem.Update();
}
}
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
graphics.IsFullScreen = true;
graphics.PreferredBackBufferWidth = 800;
graphics.PreferredBackBufferHeight = 480;
graphics.SupportedOrientations = DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight;
renderingSystem = new RenderingSystem();
physicsSystem = new PhysicsSystem();
collisionDetectionSystem = new CollisionDetectionSystem();
inputSystem = new InputSystem();
spawnSystem = new SpawnSystem();
textSystem = new TextSystem();
scoreSystem = new ScoreSystem();
}
public void TestRenderingSystem()
{
var state = new GameState();
for (int i = 0; i < NUMBER_OF_ENTITIES; ++i)
{
//state.Textures[i] =
state.GameData.Transforms[i] = new Transform(new Vector2(50.0f, 600.0f), 0.0f, new Vector2(1.0f), new Vector2(16.0f, 16.0f));
state.EntityCount++;
}
Console.WriteLine($"Number of entities: {state.EntityCount}");
for (int i = 1; i < 33; ++i)
{
var system = new RenderingSystem("Rendering", state);
RunSystem(system, i);
}
state.ClearState();
}
public static GameContext GetIngameContext(NamelessGame game)
{
if (IngameContext != null)
{
return(IngameContext);
}
else
{
var systems = new List <ISystem>();
systems.Add(new InputSystem(new IngameKeyIntentTraslator(), game));
systems.Add(new IngameIntentSystem());
systems.Add(new AiSystem());
systems.Add(new TurnManagementSystem());
systems.Add(new CombatSystem());
systems.Add(new InventorySystem());
systems.Add(new SwitchSystem());
systems.Add(new DamageHandlingSystem());
systems.Add(new DeathSystem());
systems.Add(new HudSystem());
systems.Add(new ChunkManagementSystem());
var renderingSystem = new RenderingSystem(game.GetSettings());
var uiSystem = new UIRenderSystem();
// create and init the UI manager
UiFactory.CreateHud(game);
IngameContext = new GameContext(systems, new List <ISystem>()
{
uiSystem, renderingSystem
},
UiFactory.HudInstance);
return(IngameContext);
}
}
//--------------------------------------
// PUBLIC METHODS
//--------------------------------------
/// <summary>Initializes the scene.</summary>
public override void Init()
{
AddSystems(new LogicSystem(),
new PhysicsSystem(),
new CameraSystem(),
mRenderer = new RenderingSystem());
#if DEBUG
AddSystem(new DebugOverlay());
#endif
base.Init();
InitCam();
// Spawn a few balls.
for (var i = 0; i < 10; i++)
{
var r = 1.0f; // TODO: Random size and mass.
CreateBall(new Vector3(0.9f * i - 3.5f, 0.3f * i, 0.0f), // Position
new Vector3(1.0f, 0.0f, 0.0f), // Velocity
r); // Reflective
}
}
public Game1()
{
graphics = new GraphicsDeviceManager(this);
graphics.PreferredBackBufferWidth = 1920;
graphics.PreferredBackBufferHeight = 1080;
IsMouseVisible = true;
Content.RootDirectory = "Content";
var gameStateManager = new GameStateManager(this);
//gameStateManager.AddGameState(new GameplayState());
gameStateManager.AddGameState(new LastMinuteGame());
Components.Add(gameStateManager);
var bs = new BehaviorSystem(this, gameStateManager);
Components.Add(bs);
var rs = new RenderingSystem(this, gameStateManager);
Components.Add(rs);
}
protected override void Viewport_UpdateBeforeOutput(Viewport viewport)
{
base.Viewport_UpdateBeforeOutput(viewport);
if (Mesh != null && needResultCompile)
{
Mesh.ResultCompile();
needResultCompile = false;
}
if (Mesh != null && Mesh.Result != null)
{
var meshBounds = Mesh.Result.SpaceBounds;
var selectedLOD = GetSelectedLOD();
//center axes
if (Mesh.EditorDisplayPivot)
{
var sizeInPixels = 35 * DpiHelper.Default.DpiScaleFactor;
var size = viewport.Simple3DRenderer.GetThicknessByPixelSize(Vector3.Zero, sizeInPixels);
//var size3 = meshBounds.CalculatedBoundingBox.GetSize();
//var size = Math.Max( size3.X, Math.Max( size3.Y, size3.Z ) ) / 20;
var thickness = size / 20;
var headHeight = size / 3;
var headRadius = headHeight / 3;
var alpha = 1.0; // 0.5;
//viewport.Simple3DRenderer.SetColor( new ColorValue( 1, 0, 0, alpha ), false, true );
//viewport.Simple3DRenderer.AddLine( Vector3.Zero, Vector3.XAxis * size );
//viewport.Simple3DRenderer.SetColor( new ColorValue( 0, 1, 0, alpha ), false, true );
//viewport.Simple3DRenderer.AddLine( Vector3.Zero, Vector3.YAxis * size );
//viewport.Simple3DRenderer.SetColor( new ColorValue( 0, 0, 1, alpha ), false, true );
//viewport.Simple3DRenderer.AddLine( Vector3.Zero, Vector3.ZAxis * size );
viewport.Simple3DRenderer.SetColor(new ColorValue(1, 0, 0, alpha), false); //, true );
viewport.Simple3DRenderer.AddArrow(Vector3.Zero, Vector3.XAxis * size, headHeight, headRadius, true, thickness);
viewport.Simple3DRenderer.SetColor(new ColorValue(0, 1, 0, alpha), false); //, true );
viewport.Simple3DRenderer.AddArrow(Vector3.Zero, Vector3.YAxis * size, headHeight, headRadius, true, thickness);
viewport.Simple3DRenderer.SetColor(new ColorValue(0, 0, 1, alpha), false); //, true );
viewport.Simple3DRenderer.AddArrow(Vector3.Zero, Vector3.ZAxis * size, headHeight, headRadius, true, thickness);
}
//vertex color
if (Mesh.EditorDisplayVertexColor)
{
var vertices = new Simple3DRenderer.Vertex[selectedLOD.ExtractedVertices.Length];
for (int n = 0; n < vertices.Length; n++)
{
var sourceVertex = selectedLOD.ExtractedVertices[n];
var vertex = new Simple3DRenderer.Vertex();
vertex.position = sourceVertex.Position;
vertex.color = RenderingSystem.ConvertColorValue(ref sourceVertex.Color);
//vertex.color = sourceVertex.Color;
//vertex.colorInvisibleBehindObjects = sourceVertex.color;
vertices[n] = vertex;
}
viewport.Simple3DRenderer.AddTriangles(vertices, selectedLOD.ExtractedIndices, false, true);
}
//triangles
if (Mesh.EditorDisplayTriangles)
{
//!!!!цвета настраивать в опциях
viewport.Simple3DRenderer.SetColor(new ColorValue(0, 0, 1, 0.7));
//viewport.DebugGeometry.SetColor( new ColorValue( 0, 0, 1, 0.3 ) );
viewport.Simple3DRenderer.AddTriangles(selectedLOD.ExtractedVerticesPositions, selectedLOD.ExtractedIndices, true, false);
}
//vertices
if (Mesh.EditorDisplayVertices)
{
var size3 = meshBounds.CalculatedBoundingBox.GetSize();
var scale = (float)Math.Max(size3.X, Math.Max(size3.Y, size3.Z)) / 200;
viewport.Simple3DRenderer.SetColor(new ColorValue(1, 0, 0, 0.7));
//viewport.DebugGeometry.SetColor( new ColorValue( 0, 1, 0, 0.7 ) );
foreach (var vertex in selectedLOD.ExtractedVerticesPositions)
{
viewport.Simple3DRenderer.AddLineThin(vertex - new Vector3F(scale, 0, 0), vertex + new Vector3F(scale, 0, 0));
viewport.Simple3DRenderer.AddLineThin(vertex - new Vector3F(0, scale, 0), vertex + new Vector3F(0, scale, 0));
viewport.Simple3DRenderer.AddLineThin(vertex - new Vector3F(0, 0, scale), vertex + new Vector3F(0, 0, scale));
}
}
//normals
if (Mesh.EditorDisplayNormals)
{
var size3 = meshBounds.CalculatedBoundingBox.GetSize();
var scale = (float)Math.Max(size3.X, Math.Max(size3.Y, size3.Z)) / 30;
viewport.Simple3DRenderer.SetColor(new ColorValue(0, 1, 0, 0.7));
foreach (var vertex in selectedLOD.ExtractedVertices)
{
if (vertex.Normal != Vector3F.Zero)
{
viewport.Simple3DRenderer.AddLineThin(vertex.Position, vertex.Position + vertex.Normal * scale);
}
}
}
//tangents
if (Mesh.EditorDisplayTangents)
{
var size3 = meshBounds.CalculatedBoundingBox.GetSize();
var scale = (float)Math.Max(size3.X, Math.Max(size3.Y, size3.Z)) / 30;
viewport.Simple3DRenderer.SetColor(new ColorValue(1, 0, 0, 0.7));
foreach (var vertex in selectedLOD.ExtractedVertices)
{
if (vertex.Tangent != Vector4F.Zero)
{
viewport.Simple3DRenderer.AddLineThin(vertex.Position, vertex.Position + vertex.Tangent.ToVector3F() * scale);
}
}
}
//binormals
if (Mesh.EditorDisplayBinormals)
{
var size3 = meshBounds.CalculatedBoundingBox.GetSize();
var scale = (float)Math.Max(size3.X, Math.Max(size3.Y, size3.Z)) / 30;
viewport.Simple3DRenderer.SetColor(new ColorValue(0, 0, 1, 0.7));
foreach (var vertex in selectedLOD.ExtractedVertices)
{
if (vertex.Normal != Vector3F.Zero && vertex.Tangent != Vector4F.Zero)
{
var v = Vector3.Cross(vertex.Tangent.ToVector3F(), vertex.Normal) * vertex.Tangent.W;
viewport.Simple3DRenderer.AddLineThin(vertex.Position, vertex.Position + v * scale);
}
}
}
//collision
if (Mesh.EditorDisplayCollision)
{
var collision = Mesh.GetComponent("Collision Definition") as Component_RigidBody;
if (collision != null)
{
ColorValue color = new ColorValue(0, 0, 1, 0.7);
//if( MotionType.Value == MotionTypeEnum.Static )
// color = ProjectSettings.Get.SceneShowPhysicsStaticColor;
//else if( rigidBody.IsActive )
// color = ProjectSettings.Get.SceneShowPhysicsDynamicActiveColor;
//else
// color = ProjectSettings.Get.SceneShowPhysicsDynamicInactiveColor;
viewport.Simple3DRenderer.SetColor(color, color * ProjectSettings.Get.HiddenByOtherObjectsColorMultiplier);
int verticesRendered = 0;
foreach (var shape in collision.GetComponents <Component_CollisionShape>(false, true, true))
{
shape.Render(viewport, Transform.Identity, false, ref verticesRendered);
}
}
}
//update PlayAnimation
if (!string.IsNullOrEmpty(Mesh.EditorPlayAnimation))
{
var animation = Mesh.ParentRoot.GetComponentByPath(Mesh.EditorPlayAnimation) as Component_Animation;
skeletonAnimationController.PlayAnimation = animation;
//viewport.CanvasRenderer.AddText( animation != null ? animation.ToString() : "null", new Vec2( .5, .5 ) );
}
else
{
skeletonAnimationController.PlayAnimation = null;
}
//skeleton
if (Mesh.EditorDisplaySkeleton)
{
var skeleton = Mesh.Skeleton.Value;
if (skeleton != null)
{
var color = new ColorValue(0, 0.5, 1, 0.7);
viewport.Simple3DRenderer.SetColor(color, color * ProjectSettings.Get.HiddenByOtherObjectsColorMultiplier);
var skeletonArrows = skeletonAnimationController.GetCurrentAnimatedSkeletonArrows();
if (skeletonArrows != null)
{
foreach (var arrow in skeletonArrows)
{
viewport.Simple3DRenderer.AddArrow(arrow.Start, arrow.End);
}
}
else
{
foreach (var bone in skeleton.GetBones())
{
var pos = bone.Transform.Value.Position;
var parent = bone.Parent as Component_SkeletonBone;
if (parent != null)
{
var from = parent.Transform.Value.Position;
viewport.Simple3DRenderer.AddArrow(from, pos);
}
}
}
}
}
//bounds
if (Mesh.EditorDisplayBounds)
{
viewport.Simple3DRenderer.SetColor(new ColorValue(1, 1, 0, 0.7));
//viewport.DebugGeometry.SetColor( new ColorValue( 1, 1, 0, 0.5 ) );
if (meshBounds.BoundingBox.HasValue)
{
viewport.Simple3DRenderer.AddBounds(meshBounds.BoundingBox.Value);
}
if (meshBounds.BoundingSphere.HasValue)
{
viewport.Simple3DRenderer.AddSphere(meshBounds.BoundingSphere.Value);
}
}
//select triangle
int triangleIndex = -1;
if (!viewport.MouseRelativeMode)
{
var ray = viewport.CameraSettings.GetRayByScreenCoordinates(viewport.MousePosition);
if (selectedLOD.RayCast(ray, Component_Mesh.CompiledData.RayCastMode.BruteforceNoCache, false, out double scale2, out int triangleIndex2))
{
triangleIndex = triangleIndex2;
}
}
//selected triangle data
if (triangleIndex != -1)
{
var vertices = selectedLOD.ExtractedVertices;
var indices = selectedLOD.ExtractedIndices;
int index0 = indices[triangleIndex * 3 + 0];
int index1 = indices[triangleIndex * 3 + 1];
int index2 = indices[triangleIndex * 3 + 2];
var showVertices = new int[] { index0, index1, index2 };
Vector3F p0 = vertices[index0].Position;
Vector3F p1 = vertices[index1].Position;
Vector3F p2 = vertices[index2].Position;
////draw connected triangles
//{
// ESet<Vector3I> triangles = new ESet<Vector3I>();
// //find triangles with indexes
// for( int nTriangle = 0; nTriangle < indices.Length / 3; nTriangle++ )
// {
// var i0 = indices[ nTriangle * 3 + 0 ];
// var i1 = indices[ nTriangle * 3 + 1 ];
// var i2 = indices[ nTriangle * 3 + 2 ];
// int c = 0;
// if( index0 == i0 || index1 == i0 || index2 == i0 )
// c++;
// if( index0 == i1 || index1 == i1 || index2 == i1 )
// c++;
// if( index0 == i2 || index1 == i2 || index2 == i2 )
// c++;
// //if( index0 == i0 || index0 == i1 || index0 == i2 ||
// // index1 == i0 || index1 == i1 || index1 == i2 ||
// // index2 == i0 || index2 == i1 || index2 == i2 )
// if( c == 2 )
// {
// Vector3I triangle = new Vector3I( i0, i1, i2 );
// if( triangle[ 1 ] < triangle[ 0 ] ) { var v = triangle[ 0 ]; triangle[ 0 ] = triangle[ 1 ]; triangle[ 1 ] = v; }
// if( triangle[ 2 ] < triangle[ 0 ] ) { var v = triangle[ 0 ]; triangle[ 0 ] = triangle[ 2 ]; triangle[ 2 ] = v; }
// if( triangle[ 2 ] < triangle[ 1 ] ) { var v = triangle[ 1 ]; triangle[ 1 ] = triangle[ 2 ]; triangle[ 2 ] = v; }
// triangles.AddWithCheckAlreadyContained( triangle );
// }
// }
// foreach( var triangle in triangles )
// {
// var v0 = vertices[ triangle[ 0 ] ].Position;
// var v1 = vertices[ triangle[ 1 ] ].Position;
// var v2 = vertices[ triangle[ 2 ] ].Position;
// //viewport.Simple3DRenderer.SetColor( new ColorValue( 0, 0, 1, 0.3 ) );
// //viewport.Simple3DRenderer.AddTriangles( new Vector3F[] { v0, v1, v2 }, Matrix4.Identity, false, false );
// viewport.Simple3DRenderer.SetColor( new ColorValue( 0, 0, 1 ) );
// viewport.Simple3DRenderer.AddLine( v0, v1 );
// viewport.Simple3DRenderer.AddLine( v1, v2 );
// viewport.Simple3DRenderer.AddLine( v2, v0 );
// }
//}
//draw triangle
{
viewport.Simple3DRenderer.SetColor(new ColorValue(1, 1, 0, 0.3));
viewport.Simple3DRenderer.AddTriangles(new Vector3F[] { p0, p1, p2 }, false, false);
viewport.Simple3DRenderer.SetColor(new ColorValue(1, 1, 0));
viewport.Simple3DRenderer.AddLine(p0, p1);
viewport.Simple3DRenderer.AddLine(p1, p2);
viewport.Simple3DRenderer.AddLine(p2, p0);
}
float maxLength = Math.Max((p0 - p1).Length(), Math.Max((p1 - p2).Length(), (p2 - p0).Length()));
float arrowLength = maxLength / 5;
float vertexRadius = maxLength / 40;
//!!!!можно еще буквами подписать как в transform tool
//normals, tangents
foreach (int nVertex in showVertices)
{
var v = vertices[nVertex];
Vector3F p = v.Position;
if (v.Normal != Vector3F.Zero)
{
viewport.Simple3DRenderer.SetColor(new ColorValue(0, 0, 1));
viewport.Simple3DRenderer.AddArrow(p, p + v.Normal * arrowLength, 0, 0, true);
if (v.Tangent != Vector4F.Zero)
{
viewport.Simple3DRenderer.SetColor(new ColorValue(1, 0, 0));
viewport.Simple3DRenderer.AddArrow(p, p + v.Tangent.ToVector3F() * arrowLength, 0, 0, true);
var bitangent = Vector3F.Cross(v.Tangent.ToVector3F(), v.Normal) * v.Tangent.W;
viewport.Simple3DRenderer.SetColor(new ColorValue(0, 1, 0));
viewport.Simple3DRenderer.AddArrow(p, p + bitangent * arrowLength, 0, 0, true);
}
}
}
//positions
{
viewport.Simple3DRenderer.SetColor(new ColorValue(1, 0, 0));
//SimpleMeshGenerator.GenerateSphere( vertexRadius, 10, 10, false, out Vec3F[] spherePositions, out int[] sphereIndices );
foreach (int nVertex in showVertices)
{
var v = vertices[nVertex];
Vector3F p = v.Position;
viewport.Simple3DRenderer.AddSphere(new Sphere(p, vertexRadius), 10, true);
//viewport.DebugGeometry.AddTriangles( spherePositions, sphereIndices, Mat4.FromTranslate( p ), false, false );
}
}
}
//highlight selected mesh geometries, materials
if (GetSelectedLODIndex() == 0)
{
var geometriesToHighlight = new ESet <Component_MeshGeometry>();
foreach (var geometry in Mesh.GetComponents <Component_MeshGeometry>()) // checkChildren: true ) )
{
if (SelectedObjectsSet.Contains(geometry))
{
geometriesToHighlight.AddWithCheckAlreadyContained(geometry);
}
var material = geometry.Material.Value;
if (material != null && SelectedObjectsSet.Contains(material))
{
geometriesToHighlight.AddWithCheckAlreadyContained(geometry);
}
}
foreach (var geometry in geometriesToHighlight)
{
var structure = geometry.VertexStructure.Value;
var vertices = geometry.Vertices.Value;
var indices = geometry.Indices.Value;
if (vertices != null & indices != null)
{
structure.GetInfo(out var vertexSize, out var holes);
var vertexCount = vertices.Length / vertexSize;
try
{
if (structure.GetElementBySemantic(VertexElementSemantic.Position, out var element) && element.Type == VertexElementType.Float3)
{
if (vertices != null && indices != null)
{
//!!!!кешировать?
var positions = ExtractChannel <Vector3F>(vertices, vertexSize, vertexCount, element.Offset);
viewport.Simple3DRenderer.SetColor(ProjectSettings.Get.SelectedColor);
viewport.Simple3DRenderer.AddTriangles(positions, indices, true, true);
}
}
}
catch (Exception e)
{
Log.Warning(e.Message);
}
}
}
}
//update selected LOD
if (Scene.RenderingPipeline.Value != null)
{
Scene.RenderingPipeline.Value.LODRange = new RangeI(Mesh.EditorDisplayLOD, Mesh.EditorDisplayLOD);
}
}
}
static void RenderViewports(Form form, out bool existActiveViewports)
{
existActiveViewports = false;
//!!!!каким-то не нужно часто обновляться
if (form.Visible && form.WindowState != FormWindowState.Minimized)
{
//get available controls
List <EngineViewportControl> toRender = new List <EngineViewportControl>();
List <EngineViewportControl> unvisible = new List <EngineViewportControl>();
foreach (var control in EngineViewportControl.allInstances)
{
if (control.IsAllowRender())
{
if (control.AutomaticUpdateFPS != 0)
{
toRender.Add(control);
}
}
else
{
unvisible.Add(control);
}
}
bool callFrame = false;
//destroy render targets for unvisible controls
foreach (var control in unvisible)
{
var context = control.Viewport?.RenderingContext;
if (context != null)
{
if (context.DynamicTexturesAreExists())
{
context.MultiRenderTarget_DestroyAll();
context.DynamicTexture_DestroyAll();
callFrame = true;
}
}
}
if (callFrame)
{
RenderingSystem.CallBgfxFrame();
RenderingSystem.CallBgfxFrame();
}
//render
if (toRender.Count != 0)
{
existActiveViewports = true;
foreach (var control in toRender)
{
control.TryRender();
}
}
}
}
public void RenderViewports(out bool existActiveViewports)
{
existActiveViewports = false;
//!!!!
//!!!!каким-то не нужно часто обновляться
if (Visible && WindowState != FormWindowState.Minimized)
{
//get available controls
List <EngineViewportControl> toRender = new List <EngineViewportControl>();
List <EngineViewportControl> unvisible = new List <EngineViewportControl>();
foreach (var control in EngineViewportControl.allInstances)
{
if (control.IsAllowRender())
{
if (control.AutomaticUpdateFPS != 0)
{
toRender.Add(control);
}
}
else
{
unvisible.Add(control);
}
}
bool callFrame = false;
//destroy render targets for unvisible controls
foreach (var control in unvisible)
{
var context = control.Viewport?.RenderingContext;
if (context != null)
{
if (context.DynamicTexturesAreExists())
{
context.MultiRenderTarget_DestroyAll();
context.DynamicTexture_DestroyAll();
callFrame = true;
}
}
}
if (callFrame)
{
RenderingSystem.CallBgfxFrame();
RenderingSystem.CallBgfxFrame();
}
//render
if (toRender.Count != 0)
{
existActiveViewports = true;
foreach (var control in toRender)
{
control.TryRender();
}
}
}
//bool allowRender = MainForm.Instance.Visible &&
// MainForm.Instance.WindowState != FormWindowState.Minimized &&
// MainForm.Instance.IsAllowRenderScene();
//internal bool IsAllowRenderScene()
//{
// if( runMapProcess != null )
// return false;
// if( !timer1.Enabled )
// return false;
// Form activeForm = ActiveForm;
// if( activeForm == null )
// return false;
// string fullName = activeForm.GetType().FullName;
// if( fullName == "System.Windows.Forms.PropertyGridInternal.PropertyGridView+DropDownHolder" )
// return true;
// if( fullName == "WeifenLuo.WinFormsUI.Docking.FloatWindow" )
// return true;
// //MapCompositorManager form
// {
// string helper = activeForm.Tag as string;
// if( helper != null && helper == "MapCompositorManagerForm" )
// return true;
// }
// Form form = activeForm;
// while( form != null )
// {
// if( form == this )
// return true;
// if( form.Modal )
// return false;
// form = form.Owner;
// }
// return false;
//}
}
void RenderScreenshot(Component_Camera camera, string destRealFileName)
{
var renderToFile = RenderToFile;
var scene = renderToFile.ParentRoot as Component_Scene;
Component_Image texture = null;
Component_Image textureRead = null;
try
{
//create
var resolution = renderToFile.Resolution.Value;
//!!!!impl
var hdr = false; //HDR.Value;
PixelFormat format = hdr ? PixelFormat.Float16RGBA : PixelFormat.A8R8G8B8;
//PixelFormat format = hdr ? PixelFormat.Float32RGBA : PixelFormat.A8R8G8B8;
texture = ComponentUtility.CreateComponent <Component_Image>(null, true, false);
texture.CreateType = Component_Image.TypeEnum._2D;
texture.CreateSize = resolution;
texture.CreateMipmaps = false;
texture.CreateFormat = format;
texture.CreateUsage = Component_Image.Usages.RenderTarget;
texture.CreateFSAA = 0;
texture.Enabled = true;
var renderTexture = texture.Result.GetRenderTarget(0, 0);
var viewport = renderTexture.AddViewport(true, true);
viewport.AttachedScene = scene;
textureRead = ComponentUtility.CreateComponent <Component_Image>(null, true, false);
textureRead.CreateType = Component_Image.TypeEnum._2D;
textureRead.CreateSize = resolution;
textureRead.CreateMipmaps = false;
textureRead.CreateFormat = format;
textureRead.CreateUsage = Component_Image.Usages.ReadBack | Component_Image.Usages.BlitDestination;
textureRead.CreateFSAA = 0;
textureRead.Enabled = true;
//!!!!
textureRead.Result.PrepareNativeObject();
//render
//var image2D = new ImageUtility.Image2D( PixelFormat.Float32RGB, new Vector2I( size * 4, size * 3 ) );
//var position = Transform.Value.Position;
//for( int face = 0; face < 6; face++ )
//{
//Vector3 dir = Vector3.Zero;
//Vector3 up = Vector3.Zero;
////flipped
//switch( face )
//{
//case 0: dir = -Vector3.YAxis; up = Vector3.ZAxis; break;
//case 1: dir = Vector3.YAxis; up = Vector3.ZAxis; break;
//case 2: dir = Vector3.ZAxis; up = -Vector3.XAxis; break;
//case 3: dir = -Vector3.ZAxis; up = Vector3.XAxis; break;
//case 4: dir = Vector3.XAxis; up = Vector3.ZAxis; break;
//case 5: dir = -Vector3.XAxis; up = Vector3.ZAxis; break;
//}
try
{
scene.GetDisplayDevelopmentDataInThisApplicationOverride += Scene_GetDisplayDevelopmentDataInThisApplicationOverride;
var cameraSettings = new Viewport.CameraSettingsClass(viewport, camera);
//var cameraSettings = new Viewport.CameraSettingsClass( viewport, 1, 90, NearClipPlane.Value, FarClipPlane.Value, position, dir, up, ProjectionType.Perspective, 1, 1, 1 );
viewport.Update(true, cameraSettings);
//clear temp data
viewport.RenderingContext.MultiRenderTarget_DestroyAll();
viewport.RenderingContext.DynamicTexture_DestroyAll();
}
finally
{
scene.GetDisplayDevelopmentDataInThisApplicationOverride -= Scene_GetDisplayDevelopmentDataInThisApplicationOverride;
}
texture.Result.GetRealObject(true).BlitTo(viewport.RenderingContext.CurrentViewNumber, textureRead.Result.GetRealObject(true), 0, 0);
//!!!!pitch
//get data
var totalBytes = PixelFormatUtility.GetNumElemBytes(format) * resolution.X * resolution.Y;
var data = new byte[totalBytes];
unsafe
{
fixed(byte *pBytes = data)
{
var demandedFrame = textureRead.Result.GetRealObject(true).Read((IntPtr)pBytes, 0);
while (RenderingSystem.CallBgfxFrame() < demandedFrame)
{
}
}
}
var image = new ImageUtility.Image2D(format, resolution, data);
//reset alpha channel
for (int y = 0; y < image.Size.Y; y++)
{
for (int x = 0; x < image.Size.X; x++)
{
var pixel = image.GetPixel(new Vector2I(x, y));
pixel.W = 1.0f;
image.SetPixel(new Vector2I(x, y), pixel);
}
}
//image.Data
//image2D.Blit( index * size, faceImage );
//Vector2I index = Vector2I.Zero;
//switch( face )
//{
//case 0: index = new Vector2I( 2, 1 ); break;
//case 1: index = new Vector2I( 0, 1 ); break;
//case 2: index = new Vector2I( 1, 0 ); break;
//case 3: index = new Vector2I( 1, 2 ); break;
//case 4: index = new Vector2I( 1, 1 ); break;
//case 5: index = new Vector2I( 3, 1 ); break;
//}
//var faceImage = new ImageUtility.Image2D( format, new Vector2I( size, size ), data );
//image2D.Blit( index * size, faceImage );
//}
if (!Directory.Exists(Path.GetDirectoryName(destRealFileName)))
{
Directory.CreateDirectory(Path.GetDirectoryName(destRealFileName));
}
if (!ImageUtility.Save(destRealFileName, image.Data, image.Size, 1, image.Format, 1, 0, out var error))
{
throw new Exception(error);
}
}
catch (Exception e)
{
EditorMessageBox.ShowWarning(e.Message);
return;
}
finally
{
texture?.Dispose();
textureRead?.Dispose();
}
ScreenNotifications.Show("Rendering completed successfully.");
}
void RenderMaterial(Component_Camera camera, string destRealFileName)
{
var renderToFile = RenderToFile;
var scene = renderToFile.ParentRoot as Component_Scene;
var textureFileNames = new string[5];
//ImageUtility.Image2D opacityImage = null;
Vector2I[,] opacityImageNearestCellTable = null;
//write textures
for (int nChannel = 0; nChannel < 5; nChannel++)
{
var channel = (MaterialChannel)nChannel;
Component_Image texture = null;
Component_Image textureRead = null;
try
{
//!!!!все каналы
//!!!!какие еще параметры?
var prefix = Path.GetFileNameWithoutExtension(destRealFileName) + "_";
string fileName = "";
switch (nChannel)
{
case 0: fileName = prefix + "Opacity.png"; break;
case 1: fileName = prefix + "BaseColor.png"; break;
case 2: fileName = prefix + "Metallic.png"; break;
case 3: fileName = prefix + "Roughness.png"; break;
case 4: fileName = prefix + "Normal.png"; break;
}
var fullPath = Path.Combine(Path.GetDirectoryName(destRealFileName), fileName);
//create
var resolution = renderToFile.Resolution.Value;
PixelFormat format = PixelFormat.A8R8G8B8;
texture = ComponentUtility.CreateComponent <Component_Image>(null, true, false);
texture.CreateType = Component_Image.TypeEnum._2D;
texture.CreateSize = resolution;
texture.CreateMipmaps = false;
texture.CreateFormat = format;
texture.CreateUsage = Component_Image.Usages.RenderTarget;
texture.CreateFSAA = 0;
texture.Enabled = true;
var renderTexture = texture.Result.GetRenderTarget(0, 0);
var viewport = renderTexture.AddViewport(true, true);
viewport.AttachedScene = scene;
textureRead = ComponentUtility.CreateComponent <Component_Image>(null, true, false);
textureRead.CreateType = Component_Image.TypeEnum._2D;
textureRead.CreateSize = resolution;
textureRead.CreateMipmaps = false;
textureRead.CreateFormat = format;
textureRead.CreateUsage = Component_Image.Usages.ReadBack | Component_Image.Usages.BlitDestination;
textureRead.CreateFSAA = 0;
textureRead.Enabled = true;
//!!!!
textureRead.Result.PrepareNativeObject();
var restorePipeline = scene.RenderingPipeline;
var pipeline = ComponentUtility.CreateComponent <Component_RenderingPipeline_Default>(null, true, true);
switch (nChannel)
{
case 0: pipeline.DebugMode = Component_RenderingPipeline_Basic.DebugModeEnum.Normal; break;
case 1: pipeline.DebugMode = Component_RenderingPipeline_Basic.DebugModeEnum.BaseColor; break;
case 2: pipeline.DebugMode = Component_RenderingPipeline_Basic.DebugModeEnum.Metallic; break;
case 3: pipeline.DebugMode = Component_RenderingPipeline_Basic.DebugModeEnum.Roughness; break;
case 4: pipeline.DebugMode = Component_RenderingPipeline_Basic.DebugModeEnum.Normal; break;
}
try
{
scene.RenderingPipeline = pipeline;
scene.GetDisplayDevelopmentDataInThisApplicationOverride += Scene_GetDisplayDevelopmentDataInThisApplicationOverride;
var cameraSettings = new Viewport.CameraSettingsClass(viewport, camera);
viewport.Update(true, cameraSettings);
//clear temp data
viewport.RenderingContext.MultiRenderTarget_DestroyAll();
viewport.RenderingContext.DynamicTexture_DestroyAll();
}
finally
{
scene.RenderingPipeline = restorePipeline;
scene.GetDisplayDevelopmentDataInThisApplicationOverride -= Scene_GetDisplayDevelopmentDataInThisApplicationOverride;
}
texture.Result.GetRealObject(true).BlitTo(viewport.RenderingContext.CurrentViewNumber, textureRead.Result.GetRealObject(true), 0, 0);
//!!!!pitch
//get data
var totalBytes = PixelFormatUtility.GetNumElemBytes(format) * resolution.X * resolution.Y;
var data = new byte[totalBytes];
unsafe
{
fixed(byte *pBytes = data)
{
var demandedFrame = textureRead.Result.GetRealObject(true).Read((IntPtr)pBytes, 0);
while (RenderingSystem.CallBgfxFrame() < demandedFrame)
{
}
}
}
var image = new ImageUtility.Image2D(format, resolution, data);
if (channel == MaterialChannel.Opacity)
{
//convert pixels
for (int y = 0; y < image.Size.Y; y++)
{
for (int x = 0; x < image.Size.X; x++)
{
var pixel = image.GetPixel(new Vector2I(x, y));
if (pixel.ToVector3F() != Vector3F.Zero)
{
pixel = Vector4F.One;
}
else
{
pixel = Vector4F.Zero;
}
image.SetPixel(new Vector2I(x, y), pixel);
}
}
//opacityImageNearestCellTable
if (renderToFile.FillTransparentPixelsByNearPixels)
{
var boolOpacityImage = new bool[image.Size.X, image.Size.Y];
for (int y = 0; y < image.Size.Y; y++)
{
for (int x = 0; x < image.Size.X; x++)
{
var c = image.GetPixelByte(new Vector2I(x, y));
boolOpacityImage[x, y] = c.Red == 0;
}
}
var distanceMap = GetDistanceMap(image);
opacityImageNearestCellTable = new Vector2I[image.Size.X, image.Size.Y];
for (int y = 0; y < image.Size.Y; y++)
{
for (int x = 0; x < image.Size.X; x++)
{
opacityImageNearestCellTable[x, y] = new Vector2I(x, y);
}
}
var table = opacityImageNearestCellTable;
//!!!!slowly
Parallel.For(0, image.Size.Y, delegate(int y) //for( int y = 0; y < image.Size.Y; y++ )
{
for (int x = 0; x < image.Size.X; x++)
{
var transparent = boolOpacityImage[x, y];
if (transparent)
{
for (int n = 0; n < distanceMap.Length; n++) //foreach( var indexItem in distanceMap )
{
ref var indexItem = ref distanceMap[n];
var takeFrom = new Vector2I(x, y) + indexItem.offset;
if (takeFrom.X >= 0 && takeFrom.X < image.Size.X && takeFrom.Y >= 0 && takeFrom.Y < image.Size.Y)
{
var transparent2 = boolOpacityImage[takeFrom.X, takeFrom.Y];
if (!transparent2)
{
table[x, y] = takeFrom;
break;
}
}
}
}
}
});
}
}
public EntityFactory(RenderingSystem renderingSystem, IEntityWorld entityManager)
{
this.renderingSystem = renderingSystem;
this.entityManager = entityManager;
}
public unsafe void UpdateTexture(bool clearWholeTexture)
{
if (size == Vector2I.Zero)
{
return;
}
if (RenderingSystem.IsDeviceLost())
{
return;
}
if (texture != null && texture.Disposed)
{
texture = null;
}
//create texture
if (texture == null)
{
if (!CreateTexture())
{
return;
}
}
if (textureFormat != PixelFormat.A8R8G8B8 && textureFormat != PixelFormat.A8B8G8R8)
{
return;
}
GpuTexture gpuTexture = texture.Result;
int totalSize = PixelFormatUtility.GetNumElemBytes(gpuTexture.ResultFormat) * gpuTexture.ResultSize.X * gpuTexture.ResultSize.Y;
//!!!!можно каждый раз не создавать массив
byte[] data = new byte[totalSize];
//HardwarePixelBuffer pixelBuffer = texture.GetBuffer();
//pixelBuffer.Lock( HardwareBuffer.LockOptions.Discard );
//PixelBox pixelBox = pixelBuffer.GetCurrentLock();
//if( clearWholeTexture )
// NativeUtility.ZeroMemory( data, pixelBox.SlicePitch * 4 );
byte *pointer = (byte *)buffer;
for (int y = 0; y < size.Y; y++)
{
//!!!!всегда так?
int rowPitch = PixelFormatUtility.GetNumElemBytes(gpuTexture.ResultFormat) * gpuTexture.ResultSize.X;
Marshal.Copy((IntPtr)pointer, data, y * rowPitch, size.X * 4);
//NativeUtility.CopyMemory( pointer, source, length );
//pixelBox.WriteDataUnmanaged( y * pixelBox.RowPitch * 4, pointer, size.X * 4 );
pointer += size.X * 4;
}
//pixelBuffer.Unlock();
var d = new GpuTexture.SurfaceData[] { new GpuTexture.SurfaceData(0, 0, data) };
gpuTexture.SetData(d);
needUpdateTexture = false;
}
