private static RaySceneQueryResult.Enumerator GetRaySceneQuery(double x, double y, out Ray ray)
{
float width = Engine.Renderer.Camera.Viewport.ActualWidth;
float height = Engine.Renderer.Camera.Viewport.ActualHeight;
Ray mouseRay = Engine.Renderer.Camera.GetCameraToViewportRay((float)((x - 1) / width), (float)((y - 1) / height));
RaySceneQuery mRaySceneQuery = Engine.Renderer.Scene.CreateRayQuery(mouseRay);
mRaySceneQuery.QueryTypeMask =
SceneManager.ENTITY_TYPE_MASK |
SceneManager.STATICGEOMETRY_TYPE_MASK |
SceneManager.USER_TYPE_MASK_LIMIT |
SceneManager.FRUSTUM_TYPE_MASK |
SceneManager.FX_TYPE_MASK |
SceneManager.LIGHT_TYPE_MASK |
SceneManager.WORLD_GEOMETRY_TYPE_MASK;
mRaySceneQuery.SetSortByDistance(true, 16);
RaySceneQueryResult result = mRaySceneQuery.Execute();
RaySceneQueryResult.Enumerator itr = (RaySceneQueryResult.Enumerator)(result.GetEnumerator());
ray = mouseRay;
return(itr);
}
public override void enter()
{
AdvancedMogreFramework.Singleton.m_pLog.LogMessage("Entering GameState...");
AdvancedMogreFramework.lastState = "GameState";
m_pSceneMgr = AdvancedMogreFramework.Singleton.m_pRoot.CreateSceneManager(SceneType.ST_GENERIC, "GameSceneMgr");
ColourValue cvAmbineLight = new ColourValue(0.7f, 0.7f, 0.7f);
m_pSceneMgr.AmbientLight = cvAmbineLight;//(Ogre::ColourValue(0.7f, 0.7f, 0.7f));
Ray r = new Ray();
m_pRSQ = m_pSceneMgr.CreateRayQuery(r);
m_pRSQ.QueryMask = 1 << 0;
m_pCamera = m_pSceneMgr.CreateCamera("GameCamera");
Mogre.Vector3 vectCameraPostion = new Mogre.Vector3(5, 60, 60);
m_pCamera.Position = vectCameraPostion;
Mogre.Vector3 vectorCameraLookAt = new Mogre.Vector3(5, 20, 0);
m_pCamera.LookAt(vectorCameraLookAt);
m_pCamera.NearClipDistance = 5;
m_pCamera.AspectRatio = AdvancedMogreFramework.Singleton.m_pViewport.ActualWidth / AdvancedMogreFramework.Singleton.m_pViewport.ActualHeight;
AdvancedMogreFramework.Singleton.m_pViewport.Camera = m_pCamera;
m_pCurrentObject = null;
buildGUI();
createScene();
}
public float GetTSMHeightAt(float x, float z)
{
float y = 0.0f;
Ray updateRay = new Ray();
updateRay.Origin = new Vector3(x, 9999, z);
updateRay.Direction = Vector3.NEGATIVE_UNIT_Y;
using (RaySceneQuery tsmRaySceneQuery = this.sceneMgr.CreateRayQuery(updateRay))
{
using (RaySceneQueryResult qryResult = tsmRaySceneQuery.Execute())
{
RaySceneQueryResult.Iterator i = qryResult.Begin();
if (i != qryResult.End() && i.Value.worldFragment != null)
{
y = i.Value.worldFragment.singleIntersection.y;
}
}
this.sceneMgr.DestroyQuery(tsmRaySceneQuery);
}
return(y);
}
private VanillaNonPlayer GetSelectedNPC()
{
RaySceneQuery raySceneQuery = this.mStateMgr.SceneMgr.CreateRayQuery(this.mStateMgr.Camera.GetCameraToViewportRay(0.5f, 0.5f));
raySceneQuery.SetSortByDistance(true);
foreach (RaySceneQueryResultEntry raySQREntry in raySceneQuery.Execute())
{
if (raySQREntry.movable != null)
{
string name = raySQREntry.movable.Name;
if (!name.Contains("CharacterEnt_"))
{
continue;
}
int id = int.Parse(name.Split('_')[1]);
VanillaNonPlayer npc = this.mStateMgr.MainState.CharacMgr.GetCharacterById(id) as VanillaNonPlayer;
if (npc != null)
{
return(npc);
}
}
}
return(null);
}
protected override void SetupContent()
{
SceneManager.SetSkyBox(true, "Examples/StormySkyBox", 5000); // add a skybox
// setup some basic lighting for our scene
SceneManager.AmbientLight = new ColorEx(0.5f, 0.5f, 0.5f);
SceneManager.CreateLight("DynTexLight1").Position = new Vector3(20, 80, 50);
// set initial camera position
CameraManager.setStyle(CameraStyle.Manual);
Camera.Position = new Vector3(0, 0, 200);
TrayManager.ShowCursor();
// create our dynamic texture with 8-bit luminance texels
var tex = TextureManager.Instance.CreateManual("thaw", ResourceGroupManager.DefaultResourceGroupName,
TextureType.TwoD, TEXTURE_SIZE, TEXTURE_SIZE, 0, PixelFormat.L8,
TextureUsage.DynamicWriteOnly);
this.mTexBuf = tex.GetBuffer(); // save off the texture buffer
// initialise the texture to have full luminance
this.mTexBuf.Lock(BufferLocking.Discard);
Memory.Set(this.mTexBuf.CurrentLock.Data, 0xff, this.mTexBuf.Size);
this.mTexBuf.Unlock();
// create a penguin and attach him to our penguin node
var penguin = SceneManager.CreateEntity("Penguin", "penguin.mesh");
this.mPenguinNode = SceneManager.RootSceneNode.CreateChildSceneNode();
this.mPenguinNode.AttachObject(penguin);
// get and enable the penguin idle animation
this.mPenguinAnimState = penguin.GetAnimationState("amuse");
this.mPenguinAnimState.IsEnabled = true;
// create a snowstorm over the scene, and fast forward it a little
var ps = ParticleSystemManager.Instance.CreateSystem("Snow", "Examples/Snow");
SceneManager.RootSceneNode.AttachObject(ps);
ps.FastForward(30);
// create a frosted screen in front of the camera, using our dynamic texture to "thaw" certain areas
var ent = SceneManager.CreateEntity("Plane", PrefabEntity.Plane);
ent.MaterialName = "Examples/Frost";
var node = SceneManager.RootSceneNode.CreateChildSceneNode();
node.Position = new Vector3(0, 0, 50);
node.AttachObject(ent);
this.mPlaneSize = ent.BoundingBox.Size.x; // remember the size of the plane
this.mCursorQuery = SceneManager.CreateRayQuery(new Ray()); // create a ray scene query for the cursor
this.mTimeSinceLastFreeze = 0;
this.mWiping = false;
}
public MogreRaycaster()
{
var sceneMgr = LKernel.GetG<SceneManager>();
// create the ray scene query object
raySceneQuery = sceneMgr.CreateRayQuery(new Ray()/*, SceneManager.WORLD_GEOMETRY_TYPE_MASK*/);
if (raySceneQuery != null) {
raySceneQuery.SetSortByDistance(true);
}
}
// intersects objects in scene with ray from screen coords: x, y
public static RaySceneQueryResult Pick(SceneManager mgr, int x, int y, Viewport vp, Camera cam)
{
//normalise mouse coordinates to [0,1]
//we could have used the panel's width/height in pixels instead of viewport's width/height
float scrx = (float)x / vp.ActualWidth;
float scry = (float)y / vp.ActualHeight;
Ray ray = cam.GetCameraToViewportRay(scrx, scry);
RaySceneQuery query = mgr.CreateRayQuery(ray);
RaySceneQueryResult results = query.Execute();
return(results);
}
/// <summary>
/// private method for selection object that creates a box from a single mouse click
/// </summary>
private void PerformSelectionWithMouseClick()
{
Log("MouseSelector: " + this._name + " single click selecting at (" + this._start.x.ToString() + ";" +
this._start.y.ToString() +
")");
Ray mouseRay = this._Camera.GetCameraToViewportRay(this._start.x, this._start.y);
RaySceneQuery RayScnQuery = Root.Instance.SceneManager.CreateRayQuery(mouseRay);
RayScnQuery.SortByDistance = true;
foreach (RaySceneQueryResultEntry re in RayScnQuery.Execute())
{
SelectObject(re.SceneObject);
}
}
// Just override the mandatory create scene method
public override void CreateScene()
{
// Set ambient light
sceneMgr.AmbientLight = new ColourValue(0.5f, 0.5f, 0.5f);
// Create a light
Light l = sceneMgr.CreateLight("MainLight");
// Accept default settings: point light, white diffuse, just set position
// NB I could attach the light to a SceneNode if I wanted it to move automatically with
// other objects, but I don't
l.SetPosition(20, 80, 50);
// Fog
// NB it's VERY important to set this before calling setWorldGeometry
// because the vertex program picked will be different
ColourValue fadeColour = new ColourValue(0.93f, 0.86f, 0.76f);
sceneMgr.SetFog(FogMode.FOG_LINEAR, fadeColour, .001f, 500, 1000);
window.GetViewport(0).BackgroundColour = fadeColour;
string terrain_cfg = "terrain.cfg";
sceneMgr.SetWorldGeometry(terrain_cfg);
// Infinite far plane?
if (root.RenderSystem.Capabilities.HasCapability(Capabilities.RSC_INFINITE_FAR_PLANE))
{
camera.FarClipDistance = 0;
}
// Define the required skyplane
Plane plane;
// 5000 world units from the camera
plane.d = 5000;
// Above the camera, facing down
plane.normal = -Vector3.UNIT_Y;
// Set a nice viewpoint
camera.SetPosition(707, 2500, 528);
camera.Orientation = new Quaternion(-0.3486f, 0.0122f, 0.9365f, 0.0329f);
//mRoot -> showDebugOverlay( true );
raySceneQuery = sceneMgr.CreateRayQuery(
new Ray(camera.Position, Vector3.NEGATIVE_UNIT_Y));
}
public void updateFilpTerrain()
{
Ray ray = new Ray(Position, Mogre.Vector3.NEGATIVE_UNIT_Y);
RaySceneQuery rayQuery = mCamera.SceneManager.CreateRayQuery(ray);
RaySceneQueryResult rayQueryResult = rayQuery.Execute();
foreach (var result in rayQueryResult)
{
if (result.worldFragment != null)
{
mBodyNode.SetPosition(
Position.x,
result.worldFragment.singleIntersection.y + 10,
Position.z);
}
}
}
public bool Update(BulletManager bulletMgr, float frameTime)
{
if (this.mDistTravalled >= this.Range)
{
return(false);
}
float distance = this.Speed * frameTime;
this.mDistTravalled += distance;
this.mYawNode.Translate(distance * this.mForwardDir, Node.TransformSpace.TS_LOCAL);
if (this.mAccurateTest)
{
this.mRay.Origin = this.mYawNode.Position;
if (
!(bulletMgr.World.getIsland()
.getBlock(MainWorld.getRelativeFromAbsolute(this.mYawNode.Position), false) is Air))
{
return(false);
}
RaySceneQuery raySQuery = bulletMgr.SceneMgr.CreateRayQuery(this.mRay);
raySQuery.SetSortByDistance(true);
foreach (RaySceneQueryResultEntry raySQREntry in raySQuery.Execute())
{
if (raySQREntry.movable != null && raySQREntry.distance > 0 && raySQREntry.distance <= distance)
{
string[] s = raySQREntry.movable.Name.Split('_');
if (s.Length == 2 && s[0] == "CharacterEnt")
{
int id = int.Parse(s[1]);
if (id != this.mSource.Info.Id)
{
bulletMgr.CharacMgr.GetCharacterById(id).Hit(this.Damage, this.mSource);
return(false);
}
}
}
}
}
return(true);
}
protected RaySceneQueryResult RaycastBoundingBox(Ray ray)
{
raySceneQuery = this.sceneManager.CreateRayQuery(ray);
raySceneQuery.SetSortByDistance(true);
// check we are initialised
if (raySceneQuery != null)
{
// create a query object
raySceneQuery.Ray = ray;
raySceneQuery.SetSortByDistance(true);
raySceneQuery.QueryMask = 1;
// execute the query, returns a vector of hits
return(raySceneQuery.Execute());
}
return(null);
}
// Just override the mandatory create scene method
public override void CreateScene()
{
// Set ambient light
sceneMgr.AmbientLight = new ColourValue(0.5f, 0.5f, 0.5f);
// Create a light
Light l = sceneMgr.CreateLight("MainLight");
// Accept default settings: point light, white diffuse, just set position
// NB I could attach the light to a SceneNode if I wanted it to move automatically with
// other objects, but I don't
l.SetPosition(20,80,50);
// Fog
// NB it's VERY important to set this before calling setWorldGeometry
// because the vertex program picked will be different
ColourValue fadeColour = new ColourValue(0.93f, 0.86f, 0.76f);
sceneMgr.SetFog(FogMode.FOG_LINEAR, fadeColour, .001f, 500, 1000);
window.GetViewport(0).BackgroundColour = fadeColour;
string terrain_cfg = "terrain.cfg";
sceneMgr.SetWorldGeometry( terrain_cfg );
// Infinite far plane?
if (root.RenderSystem.Capabilities.HasCapability(Capabilities.RSC_INFINITE_FAR_PLANE))
{
camera.FarClipDistance = 0;
}
// Define the required skyplane
Plane plane;
// 5000 world units from the camera
plane.d = 5000;
// Above the camera, facing down
plane.normal = -Vector3.UNIT_Y;
// Set a nice viewpoint
camera.SetPosition(707,2500,528);
camera.Orientation = new Quaternion(-0.3486f, 0.0122f, 0.9365f, 0.0329f);
//mRoot -> showDebugOverlay( true );
raySceneQuery = sceneMgr.CreateRayQuery(
new Ray(camera.Position, Vector3.NEGATIVE_UNIT_Y));
}
public void Dispose()
{
if (material != null)
{
material.Dispose();
material = null;
}
if (root != null)
{
sceneMgr.DestroyQuery(raySceneQuery);
raySceneQuery = null;
root.Dispose();
root = null;
camera = null;
sceneMgr = null;
viewport = null;
window = null;
hWnd = (IntPtr)0;
}
}
private void picRender_MouseClick(object sender, MouseEventArgs e)
{
if (e.Button != MouseButtons.Right)
{
return;
}
SelectedItem = "";
RaySceneQuery mRaySceneQuery = null;
// Save mouse position
float mouseX = (float)e.X / picRender.Width; float mouseY = (float)e.Y / picRender.Height;
// Setup the ray scene query
Ray mouseRay = mgr.GetCamera("Camera").GetCameraToViewportRay(mouseX, mouseY);
mRaySceneQuery = mgr.CreateRayQuery(mouseRay);
// Execute query
RaySceneQueryResult result = mRaySceneQuery.Execute();
RaySceneQueryResultEntry oneobj;
ctxPickObject.Items.Clear();
// Get results, create a node/entity on the position
for (Int16 i = 0; i < result.Count; i++)
{
oneobj = result[i];
if (oneobj.movable != null && oneobj.movable.Name != "canvas")
{
ctxPickObject.Items.Add(oneobj.movable.Name).Click += new EventHandler(ItemPicked);
}
} //
ctxPickObject.Show(picRender, e.X, e.Y);
drawFrame();
}
protected Vector3 GetFirstRealHit(Vector3 origin, Vector3 direction)
{
Vector3 hit = origin;
float minDistance = float.MaxValue;
RaySceneQuery raySceneQuery = CameraCS.SceneManager.CreateRayQuery(new Ray(origin, direction));
RaySceneQueryResult result = raySceneQuery.Execute();
var iterator = result.GetEnumerator();
bool intersect = false;
while (iterator.MoveNext() /*&& !intersect*/)
//! @todo are the results ordered ?? if so, uncomment (optimization)
{
var itr = iterator.Current;
if (itr.distance < minDistance && // take the shorter
itr.movable.ParentSceneNode != CameraCS.CameraSceneNode &&
itr.movable.ParentSceneNode != CameraCS.TargetNode &&
!_ignoreList.Contains(itr.movable))
{
minDistance = itr.distance;
intersect = true;
if (itr.worldFragment != null)
{
hit = itr.worldFragment.singleIntersection;
}
else //if(itr.movable)
{
hit = origin + (direction * itr.distance);
}
}
}
CameraCS.SceneManager.DestroyQuery(raySceneQuery);
return(hit);
}
public static Vector3 GetBestLocationFromYDown(Vector3 vector, float fallbackY, float sizeY)
{
Ray ray = new Ray(vector + new Vector3(0, (float.MaxValue), 0), Vector3.NEGATIVE_UNIT_Y);
RaySceneQuery mRaySceneQuery = Engine.Renderer.Scene.CreateRayQuery(ray);
mRaySceneQuery.SetSortByDistance(true, 64);
mRaySceneQuery.QueryMask = (uint)QueryFlags.INSTANCE_ENTITY;
mRaySceneQuery.QueryTypeMask =
SceneManager.ENTITY_TYPE_MASK |
SceneManager.STATICGEOMETRY_TYPE_MASK |
SceneManager.USER_TYPE_MASK_LIMIT |
SceneManager.FRUSTUM_TYPE_MASK |
SceneManager.FX_TYPE_MASK |
SceneManager.LIGHT_TYPE_MASK |
SceneManager.WORLD_GEOMETRY_TYPE_MASK;
RaySceneQueryResult result = mRaySceneQuery.Execute();
RaySceneQueryResult.Enumerator itr = (RaySceneQueryResult.Enumerator)(result.GetEnumerator());
Vector3 max = new Vector3(vector.x, fallbackY, vector.z);
if (itr != null)
{
while (itr.MoveNext())
{
RaySceneQueryResultEntry entry = itr.Current;
SceneNode parentNode = entry.movable.ParentSceneNode;
Vector3 current = new Vector3(vector.x, parentNode.Position.y + sizeY, vector.z);
if (current.y > max.y)
{
max = current;
}
}
}
return(max);
}
public override void Dispose()
{
mRay.Dispose();
mRay = null;
mRaySceneQuery.Dispose();
mRaySceneQuery = null;
/*if (myLine != null)
* {
* SceneNode n = mSceneManager.GetSceneNode("Line1");
* if (n!= null)
* n.DetachObject(myLine);
* myLine.Dispose();
* }*/
myLine.Dispose();
myLine = null;
mLog.Dispose();
mLog = null;
base.Dispose();
}
protected override void CreateScene()
{
viewport.BackgroundColor = ColorEx.White;
scene.AmbientLight = new ColorEx(0.5f, 0.5f, 0.5f);
Light light = scene.CreateLight("MainLight");
light.Position = new Vector3(20, 80, 50);
light.Diffuse = ColorEx.Blue;
scene.LoadWorldGeometry("landscape.xml");
// scene.SetFog(FogMode.Exp2, ColorEx.White, .008f, 0, 250);
// water plane setup
Plane waterPlane = new Plane(Vector3.UnitY, 1.5f);
MeshManager.Instance.CreatePlane(
"WaterPlane",
waterPlane,
2800, 2800,
20, 20,
true, 1,
10, 10,
Vector3.UnitZ);
Entity waterEntity = scene.CreateEntity("Water", "WaterPlane");
waterEntity.MaterialName = "Terrain/WaterPlane";
waterNode = scene.RootSceneNode.CreateChildSceneNode("WaterNode");
waterNode.AttachObject(waterEntity);
waterNode.Translate(new Vector3(1000, 0, 1000));
raySceneQuery = scene.CreateRayQuery(new Ray(camera.Position, Vector3.NegativeUnitY));
}
private bool FrameStarted(FrameEvent evt)
{
// Check camera height
RaySceneQuery raySceneQuery = sceneMgr.CreateRayQuery(new Ray(camera.Position + new Vector3(0, 1000000, 0), Vector3.NEGATIVE_UNIT_Y));
RaySceneQueryResult qryResult = raySceneQuery.Execute();
RaySceneQueryResult.Iterator it = qryResult.Begin();
if (it != qryResult.End() && it.Value.worldFragment != null)
{
if (camera.DerivedPosition.y < it.Value.worldFragment.singleIntersection.y + 30)
{
camera.SetPosition(camera.Position.x,
it.Value.worldFragment.singleIntersection.y + 30,
camera.Position.z);
}
it.MoveNext();
}
//SkyX::AtmosphereManager::Options SkyXOptions = mSkyX->getAtmosphereManager()->getOptions();
// Time
if (!showInformation)
{
manager.TimeMultiplier = 0.1f;
}
else
{
manager.TimeMultiplier = 0.0f;
}
textArea.Caption = GetConfigString();
manager.Update(evt.timeSinceLastFrame);
return(true);
}
public RaycastResult Raycast(Ray ray, uint queryMask)
{
RaycastResult rr = new RaycastResult();
RaySceneQuery raySceneQuery = this.sceneMgr.CreateRayQuery(new Ray());
raySceneQuery.SetSortByDistance(true);
// check we are initialised
if (raySceneQuery != null)
{
// create a query object
raySceneQuery.Ray = ray;
raySceneQuery.SetSortByDistance(true);
raySceneQuery.QueryMask = queryMask;
using (RaySceneQueryResult queryResult = raySceneQuery.Execute())
{
// execute the query, returns a vector of hits
if (queryResult.Count <= 0)
{
// raycast did not hit an objects bounding box
this.sceneMgr.DestroyQuery(raySceneQuery);
raySceneQuery.Dispose();
return(null);
}
// at this point we have raycast to a series of different objects bounding boxes.
// we need to test these different objects to see which is the first polygon hit.
// there are some minor optimizations (distance based) that mean we wont have to
// check all of the objects most of the time, but the worst case scenario is that
// we need to test every triangle of every object.
// Ogre::Real closest_distance = -1.0f;
rr.Distance = -1.0f;
Vector3 closestResult = Vector3.ZERO;
for (int qridx = 0; qridx < queryResult.Count; qridx++)
{
// stop checking if we have found a raycast hit that is closer
// than all remaining entities
if (rr.Distance >= 0.0f && rr.Distance < queryResult[qridx].distance)
{
break;
}
// only check this result if its a hit against an entity
if (queryResult[qridx].movable != null &&
queryResult[qridx].movable.MovableType == "Entity")
{
// get the entity to check
Entity entity = (Entity)queryResult[qridx].movable;
// mesh data to retrieve
Vector3[] vertices;
int[] indices;
RenderOperation.OperationTypes opType;
// get the mesh information
using (MeshPtr mesh = entity.GetMesh())
{
opType = mesh.GetSubMesh(0).operationType;
Debug.Assert(CheckSubMeshOpType(mesh, opType));
GetMeshInformation(
mesh,
out vertices,
out indices,
entity.ParentNode._getDerivedPosition(),
entity.ParentNode._getDerivedOrientation(),
entity.ParentNode._getDerivedScale());
}
int vertexCount = vertices.Length;
int indexCount = indices.Length;
// test for hitting individual triangles on the mesh
bool newClosestFound = false;
Pair <bool, float> hit;
switch (opType)
{
case RenderOperation.OperationTypes.OT_TRIANGLE_LIST:
for (int i = 0; i < indexCount; i += 3)
{
hit = Mogre.Math.Intersects(ray, vertices[indices[i]], vertices[indices[i + 1]], vertices[indices[i + 2]], true, false);
if (CheckDistance(rr, hit))
{
newClosestFound = true;
}
}
break;
case RenderOperation.OperationTypes.OT_TRIANGLE_STRIP:
for (int i = 0; i < indexCount - 2; i++)
{
hit = Mogre.Math.Intersects(ray, vertices[indices[i]], vertices[indices[i + 1]], vertices[indices[i + 2]], true, true);
if (CheckDistance(rr, hit))
{
newClosestFound = true;
}
}
break;
case RenderOperation.OperationTypes.OT_TRIANGLE_FAN:
for (int i = 0; i < indexCount - 2; i++)
{
hit = Mogre.Math.Intersects(ray, vertices[indices[0]], vertices[indices[i + 1]], vertices[indices[i + 2]], true, true);
if (CheckDistance(rr, hit))
{
newClosestFound = true;
}
}
break;
default:
throw new Exception("invalid operation type");
}
// if we found a new closest raycast for this object, update the
// closest_result before moving on to the next object.
if (newClosestFound)
{
rr.Target = entity;
closestResult = ray.GetPoint(rr.Distance);
}
}
}
this.sceneMgr.DestroyQuery(raySceneQuery);
raySceneQuery.Dispose();
// return the result
if (rr.Distance >= 0.0f)
{
// raycast success
rr.Position = closestResult;
return(rr);
}
else
{
return(null);
}
}
}
else
{
return(null);
}
}
private static bool GetRaySceneLocationWithPlane(double x, double y, Plane plane, out Vector3 vector, SceneNode ignore)
{
float width = Engine.Renderer.Camera.Viewport.ActualWidth;
float height = Engine.Renderer.Camera.Viewport.ActualHeight;
Ray mouseRay = Engine.Renderer.Camera.GetCameraToViewportRay((float)((x - 1) / width), (float)((y - 1) / height));
Plane inverse = new Plane(-plane.normal, -plane.d);
Pair <bool, float> d0 = mouseRay.Intersects(plane);
Pair <bool, float> d1 = mouseRay.Intersects(inverse);
RaySceneQuery mRaySceneQuery = Engine.Renderer.Scene.CreateRayQuery(mouseRay);
mRaySceneQuery.SetSortByDistance(true, 16);
mRaySceneQuery.QueryMask = (uint)QueryFlags.INSTANCE_ENTITY;
mRaySceneQuery.QueryTypeMask =
SceneManager.ENTITY_TYPE_MASK |
SceneManager.STATICGEOMETRY_TYPE_MASK |
SceneManager.USER_TYPE_MASK_LIMIT |
SceneManager.FRUSTUM_TYPE_MASK |
SceneManager.FX_TYPE_MASK |
SceneManager.LIGHT_TYPE_MASK |
SceneManager.WORLD_GEOMETRY_TYPE_MASK;
RaySceneQueryResult result = mRaySceneQuery.Execute();
RaySceneQueryResult.Enumerator itr = (RaySceneQueryResult.Enumerator)(result.GetEnumerator());
if (itr != null)
{
RaySceneQueryResultEntry entry = null;
while (itr.MoveNext())
{
entry = itr.Current;
if (entry != null && !entry.movable.ParentSceneNode.Equals(ignore))
{
vector = mouseRay.GetPoint(entry.distance);
return(true);
}
}
if (d0.first)
{
Vector3 planePoint = mouseRay.GetPoint(d0.second);
if ((Engine.Renderer.Camera.Position - planePoint).Length < MAX_TRANSLATE_DRAG_DISTANCE)
{
vector = planePoint;
return(true);
}
}
if (d1.first)
{
Vector3 planePoint = mouseRay.GetPoint(d1.second);
if ((Engine.Renderer.Camera.Position - planePoint).Length < MAX_TRANSLATE_DRAG_DISTANCE)
{
vector = planePoint;
return(true);
}
else
{
vector = Vector3.ZERO;
return(false);
}
}
else
{
vector = Vector3.ZERO;
return(false);
}
}
else
{
vector = Vector3.ZERO;
return(false);
}
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(RaySceneQuery obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
/// <summary>
/// Destroys a ray scene query.
/// </summary>
/// <param name="query">The query to destroy.</param>
public void destroyQuery(RaySceneQuery query)
{
throw new NotImplementedException();
//SceneManager_destroyQuery(ogreSceneManager);
}
public void InitMogre()
{
//-----------------------------------------------------
// 1 enter ogre
//-----------------------------------------------------
root = new Root();
//-----------------------------------------------------
// 2 configure resource paths
//-----------------------------------------------------
ConfigFile cf = new ConfigFile();
cf.Load("resources.cfg", "\t:=", true);
// Go through all sections & settings in the file
ConfigFile.SectionIterator seci = cf.GetSectionIterator();
String secName, typeName, archName;
// Normally we would use the foreach syntax, which enumerates the values, but in this case we need CurrentKey too;
while (seci.MoveNext())
{
secName = seci.CurrentKey;
ConfigFile.SettingsMultiMap settings = seci.Current;
foreach (KeyValuePair <string, string> pair in settings)
{
typeName = pair.Key;
archName = pair.Value;
ResourceGroupManager.Singleton.AddResourceLocation(archName, typeName, secName);
}
}
//-----------------------------------------------------
// 3 Configures the application and creates the window
//-----------------------------------------------------
bool foundit = false;
foreach (RenderSystem rs in root.GetAvailableRenderers())
{
root.RenderSystem = rs;
String rname = root.RenderSystem.Name;
if (rname == "Direct3D9 Rendering Subsystem")
{
foundit = true;
break;
}
}
if (!foundit)
{
return; //we didn't find it... Raise exception?
}
//we found it, we might as well use it!
root.RenderSystem.SetConfigOption("Full Screen", "No");
root.RenderSystem.SetConfigOption("Video Mode", "640 x 480 @ 32-bit colour");
root.Initialise(false);
NameValuePairList misc = new NameValuePairList();
misc["externalWindowHandle"] = hWnd.ToString();
window = root.CreateRenderWindow("Simple Mogre Form Window", 0, 0, false, misc);
ResourceGroupManager.Singleton.InitialiseAllResourceGroups();
//-----------------------------------------------------
// 4 Create the SceneManager
//
// ST_GENERIC = octree
// ST_EXTERIOR_CLOSE = simple terrain
// ST_EXTERIOR_FAR = nature terrain (depreciated)
// ST_EXTERIOR_REAL_FAR = paging landscape
// ST_INTERIOR = Quake3 BSP
//-----------------------------------------------------
sceneMgr = root.CreateSceneManager(SceneType.ST_GENERIC, "SceneMgr");
sceneMgr.AmbientLight = new ColourValue(1f, 1f, 1f);
// Create a point light
Light l = sceneMgr.CreateLight("MainLight");
l.Position = new Vector3(500, 500, 500);
//-----------------------------------------------------
// 5 Create the camera
//-----------------------------------------------------
camera = sceneMgr.CreateCamera("SimpleCamera");
camera.Position = new Vector3(400f, 0f, 0f);//400
// Look back along -Z
camera.LookAt(new Vector3(-1f, 0f, 0f));
camera.NearClipDistance = 5;
viewport = window.AddViewport(camera);
viewport.BackgroundColour = new ColourValue(0.0f, 0.0f, 0.0f, 1.0f);
for (int i = 0; i < cubeCount; i++)
{
material = MaterialManager.Singleton.Create("front" + i.ToString(), "General");
material.GetTechnique(0).GetPass(0).CreateTextureUnitState((cubeCount - 1 - i).ToString() + ".jpg");
}
material = MaterialManager.Singleton.Create("other", "General");
material.GetTechnique(0).GetPass(0).CreateTextureUnitState("snow.jpg");
material = MaterialManager.Singleton.Create("back", "General");
material.GetTechnique(0).GetPass(0).CreateTextureUnitState("back2.jpg");
Vector3 moveVector3 = new Vector3(0f, -60f, 110f);
for (int i = 0; i < cubeCount; i++)
{
Cube cube = new Cube();
cube.CubeName = "cube" + i.ToString();
cube.BuildCube("front" + i.ToString(), ref sceneMgr);
ManualObject manual = sceneMgr.GetManualObject(cube.CubeName);
manual.ConvertToMesh("cubeMesh" + i.ToString());
Entity ent = sceneMgr.CreateEntity("box" + i.ToString(), "cubeMesh" + i.ToString());
SceneNode node = sceneMgr.RootSceneNode.CreateChildSceneNode("boxNode" + i.ToString());
ent.CastShadows = true;
node.AttachObject(ent);
float y = i * (Cube.cubeHeight + 10) + moveVector3.y;
node.Position = new Vector3(0f, y, moveVector3.z);
}
Plane plane = new Plane();
plane.BuildPlane("back", ref sceneMgr);
ManualObject manualPlane = sceneMgr.GetManualObject(plane.PlaneName);
manualPlane.ConvertToMesh("planeMesh");
Entity planeEntity = sceneMgr.CreateEntity("planeEntity", "planeMesh");
SceneNode planeNode = sceneMgr.RootSceneNode.CreateChildSceneNode("planeNode");
planeNode.AttachObject(planeEntity);
//载入tube1-4
SceneNode tubeRootNode = sceneMgr.RootSceneNode.CreateChildSceneNode("tubeRoot");
tubeRootNode.Position = new Vector3(0f, -110f, -170f);
for (int i = 1; i <= 4; i++)
{
string tubeName = "tube" + i.ToString();
Entity tubeEnt = sceneMgr.CreateEntity(tubeName, tubeName + ".mesh");
switch (i)
{
case 1:
tubeEnt.SetMaterialName("Examples/TextureEffect1");
break;
case 2:
tubeEnt.SetMaterialName("Examples/TextureEffect4");
break;
case 3:
tubeEnt.SetMaterialName("Examples/TextureEffect3");
break;
case 4:
tubeEnt.SetMaterialName("Examples/TextureEffect2");
break;
}
SceneNode tubeNode = tubeRootNode.CreateChildSceneNode(tubeName + "Node");
tubeNode.AttachObject(tubeEnt);
}
tubeRootNode.Scale(new Vector3(0.3f, 0.3f, 0.3f));
raySceneQuery = sceneMgr.CreateRayQuery(new Ray());
particleSystem = sceneMgr.CreateParticleSystem("partical1", "Example/Snow");
sceneMgr.RootSceneNode.CreateChildSceneNode().AttachObject(particleSystem);
}
public void Init(String handle)
{
try
{
// Create root object
mRoot = new Root();
// Define Resources
ConfigFile cf = new ConfigFile();
cf.Load("./resources.cfg", "\t:=", true);
ConfigFile.SectionIterator seci = cf.GetSectionIterator();
String secName, typeName, archName;
while (seci.MoveNext())
{
secName = seci.CurrentKey;
ConfigFile.SettingsMultiMap settings = seci.Current;
foreach (KeyValuePair <string, string> pair in settings)
{
typeName = pair.Key;
archName = pair.Value;
ResourceGroupManager.Singleton.AddResourceLocation(archName, typeName, secName);
}
}
//Load the resources from resources.cfg and selected tab (_ConfigurationPaths)
//LoadResourceLocations(_ConfigurationPaths);
//example of manual add: _FileSystemPaths.Add("../../Media/models");
foreach (string foo in _ConfigurationPaths)
{
AddResourceLocation(foo);
}
// Setup RenderSystem
mRSys = mRoot.GetRenderSystemByName("Direct3D9 Rendering Subsystem");
//mRSys = mRoot.GetRenderSystemByName("OpenGL Rendering Subsystem");
// or use "OpenGL Rendering Subsystem"
mRoot.RenderSystem = mRSys;
mRSys.SetConfigOption("Full Screen", "No");
mRSys.SetConfigOption("Video Mode", "800 x 600 @ 32-bit colour");
// Create Render Window
mRoot.Initialise(false, "Main Ogre Window");
NameValuePairList misc = new NameValuePairList();
misc["externalWindowHandle"] = handle;
misc["FSAA"] = "4";
// misc["VSync"] = "True"; //not sure how to enable vsync to remove those warnings in Ogre.log
mWindow = mRoot.CreateRenderWindow("Main RenderWindow", 800, 600, false, misc);
// Init resources
MaterialManager.Singleton.SetDefaultTextureFiltering(TextureFilterOptions.TFO_ANISOTROPIC);
TextureManager.Singleton.DefaultNumMipmaps = 5;
ResourceGroupManager.Singleton.InitialiseAllResourceGroups();
// Create a Simple Scene
//SceneNode node = null;
// mMgr = mRoot.CreateSceneManager(SceneType.ST_GENERIC, "SceneManager");
mMgr = mRoot.CreateSceneManager(SceneType.ST_EXTERIOR_CLOSE, "SceneManager");
mMgr.AmbientLight = new ColourValue(0.8f, 0.8f, 0.8f);
mCamera = mMgr.CreateCamera("Camera");
mWindow.AddViewport(mCamera);
mCamera.AutoAspectRatio = true;
mCamera.Viewport.SetClearEveryFrame(false);
//Entity ent = mMgr.CreateEntity(displayMesh, displayMesh);
//ent.SetMaterialName(displayMaterial);
//node = mMgr.RootSceneNode.CreateChildSceneNode(displayMesh + "node");
//node.AttachObject(ent);
mCamera.Position = new Vector3(0, 0, 0);
//mCamera.Position = new Vector3(0, 0, -400);
mCamera.LookAt(0, 0, 1);
//Create a single point light source
Light light2 = mMgr.CreateLight("MainLight");
light2.Position = new Vector3(0, 10, -25);
light2.Type = Light.LightTypes.LT_POINT;
light2.SetDiffuseColour(1.0f, 1.0f, 1.0f);
light2.SetSpecularColour(0.1f, 0.1f, 0.1f);
mWindow.WindowMovedOrResized();
IsInitialized = true;
// Create the camera's top node (which will only handle position).
cameraNode = mMgr.RootSceneNode.CreateChildSceneNode();
cameraNode.Position = new Vector3(0, 0, 0);
//cameraNode = mMgr->getRootSceneNode()->createChildSceneNode();
//cameraNode->setPosition(0, 0, 500);
// Create the camera's yaw node as a child of camera's top node.
cameraYawNode = cameraNode.CreateChildSceneNode();
// Create the camera's pitch node as a child of camera's yaw node.
cameraPitchNode = cameraYawNode.CreateChildSceneNode();
// Create the camera's roll node as a child of camera's pitch node
// and attach the camera to it.
cameraRollNode = cameraPitchNode.CreateChildSceneNode();
cameraRollNode.AttachObject(mCamera);
mRaySceneQuery = mMgr.CreateRayQuery(new Ray());
}
catch (Exception ex)
{
Console.WriteLine("[Error,OgreForm.cs]: " + ex.Message + "," + ex.StackTrace);
}
}
/*** test ***/
protected override void CreateScene()
{
mSceneManager.SetSkyBox(true, "Examples/CloudyNoonSkyBox");
mLog = LogManager.Singleton.createLog("RSQTest.log", false, true);
mLog.LogMessage(string.Format("RSQTest log {0}", System.DateTime.Now));
create4LineDebugOverLay();
Show4LineDebugOverLay();
Entity e;
SceneNode n;
Plane plane = new Plane();
plane.Normal.x = 0.0f;
plane.Normal.y = 1.0f;
plane.Normal.z = 0.0f;
plane.D = 0.0f;
MeshManager.GetSingleton().CreatePlane("Myplane01", "General", plane,
250.0f, 500.0f, 10, 10, true, 1, 5.0f, 5.0f, Vector3.UnitZ);
e = mSceneManager.CreateEntity("plane01", "Myplane01");
e.SetMaterialName("Examples/GrassFloor");
e.SetCastShadows(false);
n = mSceneManager.GetRootSceneNode().CreateChildSceneNode();
n.SetPosition(-125.0f, 10.0f, 0.0f);
n.Pitch(new Radian(new Degree(5.0f)));
n.AttachObject(e);
plane.Normal.x = 0.0f;
plane.Normal.y = 1.0f;
plane.Normal.z = 0.0f;
plane.D = 0.0f;
MeshManager.GetSingleton().CreatePlane("Myplane02", "General", plane,
250.0f, 500.0f, 10, 10, true, 1, 5.0f, 5.0f, Vector3.UnitZ);
e = mSceneManager.CreateEntity("plane02", "Myplane02");
e.SetMaterialName("Examples/GrassFloor");
e.SetCastShadows(false);
n = mSceneManager.GetRootSceneNode().CreateChildSceneNode();
n.SetPosition(125.0f, 10.0f, 0.0f);
n.AttachObject(e);
for (int x = 0; x < 4; x++)
{
string sname = string.Format("head{0}", x);
e = mSceneManager.CreateEntity(sname, "ogrehead.mesh");
n = mSceneManager.GetRootSceneNode().CreateChildSceneNode(sname);
n.AttachObject(e);
float px = (x % 2 == 0? -100.0f: 100.0f);
float pz = ((x <= 1)? -100.0f: 100.0f);
float py = (x % 2 == 0? 50.0f : 30.0f);
n.SetPosition(px, py, pz);
}
mRay = new OgreDotNet.Ray(Vector3.Zero, Vector3.NegativeUnitY);
mRaySceneQuery = mSceneManager.CreateRayQuery(mRay);
mCamera.Move(new Vector3(0, 300, 600));
mCamera.LookAt = new Vector3(0, 0, 0);
/*** test ***/
myLine = new Line3D();
myLine.addPoint(new Vector3(0.0f, 9.6f, 0.0f));
myLine.addPoint(new Vector3(160.0f, 9.6f, 0.0f));
myLine.addPoint(new Vector3(160.0f, 9.6f, 160.0f));
myLine.addPoint(new Vector3(0.0f, 9.6f, 160.0f));
myLine.addPoint(new Vector3(0.0f, 9.6f, 0.0f));
myLine.drawLines();
SceneNode myNode = mSceneManager.GetRootSceneNode().CreateChildSceneNode("Line1");
myNode.AttachObject(myLine);
myNode.SetPosition(0.0f, 200.0f, 0.0f);
/*** test ***/
}
private void renderBox_MouseClick(object sender, MouseEventArgs e)
{
if (e.Button != MouseButtons.Left)
{
return;
}
foreach (MovableObject selectedNode in selectedNodes)
{
try
{
selectedNode.ParentSceneNode.ShowBoundingBox = false;
}
catch (Exception ex)
{
//log(ex.ToString());
}
}
selectedNodes = new ArrayList();
float scrx = (float)e.X / OgreWindow.Instance.mViewport.ActualWidth;
float scry = (float)e.Y / OgreWindow.Instance.mViewport.ActualHeight;
Ray ray = OgreWindow.Instance.mCamera.GetCameraToViewportRay(scrx, scry);
RaySceneQuery query = OgreWindow.Instance.mSceneMgr.CreateRayQuery(ray);
RaySceneQueryResult results = query.Execute();
float nearest = 100000000f; //100 mill
int nearestIndex = -1;
for (int i = 0; i < results.Count; i++)
{
RaySceneQueryResultEntry entry = results[i];
if (entry.movable.Name == "MainCamera")
{
continue;
}
if (entry.movable.Name.IndexOf("SphereEntity") > -1)
{
continue;
}
if (entry.movable.Name.IndexOf("SkyXMeshEnt") > -1)
{
continue;
}
if (entry.movable.Name.IndexOf("_Hydrax_GodRays_ManualObject") > -1)
{
continue;
}
if (entry.movable.Name.IndexOf("_Hydrax_GodRays_Projector_Camera") > -1)
{
continue;
}
if (entry.movable.Name.IndexOf("_Hydrax_Projector_Camera") > -1)
{
continue;
}
if (entry.movable.Name.IndexOf("HydraxMeshEnt") > -1)
{
continue;
}
bool cancel = false;
foreach (string s in preventSelect)
{
if (entry.movable.Name.IndexOf(s) > -1)
{
cancel = true;
break;
}
}
if (cancel)
{
continue;
}
if (entry.distance < nearest)
{
nearest = entry.distance;
nearestIndex = i;
}
}
if (nearestIndex > -1)
{
RaySceneQueryResultEntry entry = results[nearestIndex];
selectSceneNode(entry.movable);
}
}
protected RaySceneQueryResult RaycastBoundingBox(Ray ray)
{
raySceneQuery = this.sceneManager.CreateRayQuery(ray);
raySceneQuery.SetSortByDistance(true);
// check we are initialised
if (raySceneQuery != null)
{
// create a query object
raySceneQuery.Ray = ray;
raySceneQuery.SetSortByDistance(true);
raySceneQuery.QueryMask = 1;
// execute the query, returns a vector of hits
return raySceneQuery.Execute();
}
return null;
}
public RaycastResult Raycast(Ray ray, uint queryMask)
{
RaycastResult rr = new RaycastResult();
RaySceneQuery raySceneQuery = this.sceneMgr.CreateRayQuery(new Ray());
raySceneQuery.SetSortByDistance(true);
// check we are initialised
if (raySceneQuery != null)
{
// create a query object
raySceneQuery.Ray = ray;
raySceneQuery.SetSortByDistance(true);
raySceneQuery.QueryMask = queryMask;
// execute the query, returns a vector of hits
if (raySceneQuery.Execute().Count <= 0)
{
// raycast did not hit an objects bounding box
return(null);
}
}
else
{
// LogManager.Singleton.LogMessage("Cannot raycast without RaySceneQuery instance");
return(null);
}
// at this point we have raycast to a series of different objects bounding boxes.
// we need to test these different objects to see which is the first polygon hit.
// there are some minor optimizations (distance based) that mean we wont have to
// check all of the objects most of the time, but the worst case scenario is that
// we need to test every triangle of every object.
// Ogre::Real closest_distance = -1.0f;
rr.Distance = -1.0f;
Vector3 closest_result = Vector3.ZERO;
RaySceneQueryResult query_result = raySceneQuery.GetLastResults();
for (int qridx = 0; qridx < query_result.Count; qridx++)
{
// stop checking if we have found a raycast hit that is closer
// than all remaining entities
if ((rr.Distance >= 0.0f) && (rr.Distance < query_result[qridx].distance))
{
break;
}
// only check this result if its a hit against an entity
if ((query_result[qridx].movable != null) &&
(query_result[qridx].movable.MovableType.CompareTo("Entity") == 0))
{
// get the entity to check
Entity pentity = (Entity)query_result[qridx].movable;
// mesh data to retrieve
uint vertex_count;
uint index_count;
Vector3[] vertices;
ulong[] indices;
// get the mesh information
GetMeshInformation(
pentity.GetMesh(),
out vertex_count,
out vertices,
out index_count,
out indices,
pentity.ParentNode._getDerivedPosition(),
pentity.ParentNode._getDerivedOrientation(),
pentity.ParentNode.GetScale());
// test for hitting individual triangles on the mesh
bool new_closest_found = false;
for (int i = 0; i < (int)index_count; i += 3)
{
// check for a hit against this triangle
Pair <bool, float> hit = Mogre.Math.Intersects(ray, vertices[indices[i]], vertices[indices[i + 1]], vertices[indices[i + 2]], true, false);
// if it was a hit check if its the closest
if (hit.first)
{
if ((rr.Distance < 0.0f) ||
(hit.second < rr.Distance))
{
// this is the closest so far, save it off
rr.Distance = hit.second;
new_closest_found = true;
}
}
}
// if we found a new closest raycast for this object, update the
// closest_result before moving on to the next object.
if (new_closest_found)
{
rr.Target = pentity;
closest_result = ray.GetPoint(rr.Distance);
}
}
}
this.sceneMgr.DestroyQuery(raySceneQuery);
raySceneQuery.Dispose();
// return the result
if (rr.Distance >= 0.0f)
{
// raycast success
rr.Position = closest_result;
return(rr);
}
else
{
return(null);
}
}
public void Init(String handle)
{
try
{
// Create root object
mRoot = new Root();
// Define Resources
ConfigFile cf = new ConfigFile();
cf.Load("./resources.cfg", "\t:=", true);
ConfigFile.SectionIterator seci = cf.GetSectionIterator();
String secName, typeName, archName;
while (seci.MoveNext())
{
secName = seci.CurrentKey;
ConfigFile.SettingsMultiMap settings = seci.Current;
foreach (KeyValuePair<string, string> pair in settings)
{
typeName = pair.Key;
archName = pair.Value;
ResourceGroupManager.Singleton.AddResourceLocation(archName, typeName, secName);
}
}
//Load the resources from resources.cfg and selected tab (_ConfigurationPaths)
//LoadResourceLocations(_ConfigurationPaths);
//example of manual add: _FileSystemPaths.Add("../../Media/models");
foreach (string foo in _ConfigurationPaths)
{
AddResourceLocation(foo);
}
// Setup RenderSystem
mRSys = mRoot.GetRenderSystemByName("Direct3D9 Rendering Subsystem");
//mRSys = mRoot.GetRenderSystemByName("OpenGL Rendering Subsystem");
// or use "OpenGL Rendering Subsystem"
mRoot.RenderSystem = mRSys;
mRSys.SetConfigOption("Full Screen", "No");
mRSys.SetConfigOption("Video Mode", "800 x 600 @ 32-bit colour");
// Create Render Window
mRoot.Initialise(false, "Main Ogre Window");
NameValuePairList misc = new NameValuePairList();
misc["externalWindowHandle"] = handle;
misc["FSAA"] = "4";
// misc["VSync"] = "True"; //not sure how to enable vsync to remove those warnings in Ogre.log
mWindow = mRoot.CreateRenderWindow("Main RenderWindow", 800, 600, false, misc);
// Init resources
MaterialManager.Singleton.SetDefaultTextureFiltering(TextureFilterOptions.TFO_ANISOTROPIC);
TextureManager.Singleton.DefaultNumMipmaps = 5;
ResourceGroupManager.Singleton.InitialiseAllResourceGroups();
// Create a Simple Scene
//SceneNode node = null;
// mMgr = mRoot.CreateSceneManager(SceneType.ST_GENERIC, "SceneManager");
mMgr = mRoot.CreateSceneManager(SceneType.ST_EXTERIOR_CLOSE, "SceneManager");
mMgr.AmbientLight = new ColourValue(0.8f, 0.8f, 0.8f);
mCamera = mMgr.CreateCamera("Camera");
mWindow.AddViewport(mCamera);
mCamera.AutoAspectRatio = true;
mCamera.Viewport.SetClearEveryFrame(false);
//Entity ent = mMgr.CreateEntity(displayMesh, displayMesh);
//ent.SetMaterialName(displayMaterial);
//node = mMgr.RootSceneNode.CreateChildSceneNode(displayMesh + "node");
//node.AttachObject(ent);
mCamera.Position = new Vector3(0, 0, 0);
//mCamera.Position = new Vector3(0, 0, -400);
mCamera.LookAt(0, 0, 1);
//Create a single point light source
Light light2 = mMgr.CreateLight("MainLight");
light2.Position = new Vector3(0, 10, -25);
light2.Type = Light.LightTypes.LT_POINT;
light2.SetDiffuseColour(1.0f, 1.0f, 1.0f);
light2.SetSpecularColour(0.1f, 0.1f, 0.1f);
mWindow.WindowMovedOrResized();
IsInitialized = true;
// Create the camera's top node (which will only handle position).
cameraNode = mMgr.RootSceneNode.CreateChildSceneNode();
cameraNode.Position = new Vector3(0, 0, 0);
//cameraNode = mMgr->getRootSceneNode()->createChildSceneNode();
//cameraNode->setPosition(0, 0, 500);
// Create the camera's yaw node as a child of camera's top node.
cameraYawNode = cameraNode.CreateChildSceneNode();
// Create the camera's pitch node as a child of camera's yaw node.
cameraPitchNode = cameraYawNode.CreateChildSceneNode();
// Create the camera's roll node as a child of camera's pitch node
// and attach the camera to it.
cameraRollNode = cameraPitchNode.CreateChildSceneNode();
cameraRollNode.AttachObject(mCamera);
mRaySceneQuery = mMgr.CreateRayQuery(new Ray());
}
catch (Exception ex)
{
Console.WriteLine("[Error,OgreForm.cs]: " + ex.Message + "," + ex.StackTrace);
}
}
public bool init()
{
// Start with a new root to get this party started
root = new Root();
// Configuration buisness
ConfigFile config = new ConfigFile();
config.Load("resources.cfg", "\t:=", true);
// Go through all our configuration settings
ConfigFile.SectionIterator itor = config.GetSectionIterator();
string secName, typeName, archName;
// Move through all of the sections
while (itor.MoveNext())
{
secName = itor.CurrentKey;
ConfigFile.SettingsMultiMap settings = itor.Current;
foreach (KeyValuePair<string, string> pair in settings)
{
typeName = pair.Key;
archName = pair.Value;
ResourceGroupManager.Singleton.AddResourceLocation(archName, typeName, secName);
}
}
// Configure our window and set up the RenderSystem
bool found = false;
foreach (RenderSystem rs in root.GetAvailableRenderers())
{
root.RenderSystem = rs;
string rname = root.RenderSystem.Name;
if (rname == "Direct3D9 Rendering Subsystem")
{
found = true;
break;
}
}
// If we can't find the DirectX rendering system somethign is seriously wrong
if (!found)
return false;
root.RenderSystem.SetConfigOption("Full Screen", "No");
root.RenderSystem.SetConfigOption("Video Mode", "640 x 480 @ 32-bit colour");
root.Initialise(false);
NameValuePairList misc = new NameValuePairList();
misc["externalWindowHandle"] = hWnd.ToString();
window = root.CreateRenderWindow("Simple Mogre Form Window", 0, 0, false, misc);
ResourceGroupManager.Singleton.InitialiseAllResourceGroups();
// Create our SceneManager
sceneMgr = root.CreateSceneManager(SceneType.ST_GENERIC, "SceneMgr");
sceneMgr.AmbientLight = new ColourValue(0.5f, 0.5f, 0.5f);
sceneMgr.ShadowTechnique = ShadowTechnique.SHADOWTYPE_STENCIL_ADDITIVE;
// Create the camera
camMgr = new CamManager();
camMgr.Initialize(ref sceneMgr);
viewport = window.AddViewport(camMgr.mainCam);
viewport.BackgroundColour = new ColourValue(0, 0, 0, 1);
// Load our stick here
LoadModel("TEStick.mesh");
// Set up ground
Plane plane = new Plane(Mogre.Vector3.UNIT_Y, 0);
MeshManager.Singleton.CreatePlane("ground", ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME, plane,
1500, 1500, 20, 20, true, 1, 5, 5, Mogre.Vector3.UNIT_Z);
Entity ground = sceneMgr.CreateEntity("GroundEnt", "ground");
sceneMgr.RootSceneNode.CreateChildSceneNode().AttachObject(ground);
ground.SetMaterialName("Examples/Rockwall");
ground.CastShadows = false;
// Set up some lights
Light pointLight = sceneMgr.CreateLight("pointLight");
pointLight.Type = Light.LightTypes.LT_POINT;
pointLight.Position = new Mogre.Vector3(0, 150, 250);
pointLight.DiffuseColour = ColourValue.White;
pointLight.SpecularColour = ColourValue.White;
Light directionalLight = sceneMgr.CreateLight("directionalLight");
directionalLight.Type = Light.LightTypes.LT_DIRECTIONAL;
directionalLight.DiffuseColour = new ColourValue(.25f, .25f, 0);
directionalLight.SpecularColour = new ColourValue(.25f, .25f, 0);
directionalLight.Direction = new Mogre.Vector3(0, -1, 1);
Light spotLight = sceneMgr.CreateLight("spotLight");
spotLight.Type = Light.LightTypes.LT_SPOTLIGHT;
spotLight.DiffuseColour = ColourValue.White;
spotLight.SpecularColour = ColourValue.White;
spotLight.Direction = new Mogre.Vector3(-1, -1, 0);
spotLight.Position = new Mogre.Vector3(300, 300, 0);
spotLight.SetSpotlightRange(new Degree(35), new Degree(50));
// Set up our Input
root.FrameRenderingQueued += new FrameListener.FrameRenderingQueuedHandler(Input);
// Set up for picking
raySceneQuery = sceneMgr.CreateRayQuery(new Ray(), SceneManager.WORLD_GEOMETRY_TYPE_MASK);
if (null == raySceneQuery)
return false;
raySceneQuery.SetSortByDistance(true);
return true;
}