public void CreateShootBullet(Vector3 InitPos, Vector3 DirBullet, Color BulletColor)
{
if (BulletID == 20)
{
return;
}
GeometryNode ShootBullet = new GeometryNode("ShootBullet" + BulletID++);
ShootBullet.Model = BulletModel;
BulletrMat.Diffuse = BulletColor.ToVector4();
ShootBullet.Material = BulletrMat;
ShootBullet.Physics.Interactable = true;
ShootBullet.Physics.Collidable = true;
ShootBullet.Physics.Shape = GoblinXNA.Physics.ShapeType.Box;
ShootBullet.Physics.Mass = 60f;
ShootBullet.Physics.MaterialName = "Bullet";
ShootBullet.AddToPhysicsEngine = true;
// Assign the initial velocity to this shooting box
ShootBullet.Physics.InitialLinearVelocity = new Vector3(DirBullet.X * 80, DirBullet.Y * 80, DirBullet.Z * 50);
TransformNode BulletTrans = new TransformNode();
BulletTrans.Translation = InitPos;
groundMarkerNode.AddChild(BulletTrans);
BulletTrans.AddChild(ShootBullet);
}
private void CreateObjects()
{
float size = 4.0f;
// Create a marker node to track a feature-based image.
// NOTE: If you get an exception here, that means you haven't generated the .dat file yet
// Please see this
MarkerNode groundMarkerNode = new MarkerNode(scene.MarkerTracker, "markerless.png.dat");
// Now add the above nodes to the scene graph in the appropriate order.
// Note that only the nodes added below the marker node are affected by
// the marker transformation.
scene.RootNode.AddChild(groundMarkerNode);
// Create a geometry node with a model of a box that will be overlaid on top of the image
GeometryNode boxNode = new GeometryNode("Box")
{
Model = new Box(size),
Material = new Material()
{
Diffuse = Color.Red.ToVector4(),
Specular = Color.White.ToVector4(),
SpecularPower = 10
}
};
TransformNode boxTrans = new TransformNode()
{
Translation = new Vector3(0, 0, -size / 2)
};
groundMarkerNode.AddChild(boxTrans);
boxTrans.AddChild(boxNode);
}
/********************* Basic Elements ****************/
public GeometryNode CreateCube(MarkerNode Marker, Vector4 CubeColor)
{
GeometryNode boxNode;
// Create a geometry node with a model of a box
boxNode = new GeometryNode("Box");
boxNode.Model = new TexturedBox(32.4f);
// Add this box model to the physics engine for collision detection
boxNode.AddToPhysicsEngine = true;
boxNode.Physics.Shape = ShapeType.Box;
// Make this box model cast and receive shadows
boxNode.Model.ShadowAttribute = ShadowAttribute.ReceiveCast;
// Assign a shadow shader for this model that uses the IShadowMap we assigned to the scene
boxNode.Model.Shader = new SimpleShadowShader(GShadowMap);
// Create a material to apply to the box model
Material boxMaterial = new Material();
boxMaterial.Diffuse = CubeColor;
boxMaterial.Specular = Color.White.ToVector4();
boxMaterial.SpecularPower = 10;
boxNode.Material = boxMaterial;
// Add this box model node to the ground marker node
Marker.AddChild(boxNode);
return(boxNode);
// Create a collision pair and add a collision callback function that will be
// called when the pair collides
//NewtonPhysics.CollisionPair pair = new NewtonPhysics.CollisionPair(boxNode.Physics, sphereNode.Physics);
//((NewtonPhysics)scene.PhysicsEngine).AddCollisionCallback(pair, BoxSphereCollision);
}
private TransformNode BulletTrans; //Transfor Node for Bullet
#endregion
#region Constructors
public Bullet(Vector3 InitPos, PrimitiveModel BulletModel, Material Material, Vector3 DirBullet, MarkerNode grdMarkerNode)
{
//Create Bullet
ShootBullet = new GeometryNode();
ShootBullet.Name = "ShootBullet" + ShootBullet.ID;
ShootBullet.Model = BulletModel;
ShootBullet.Material = Material;
ShootBullet.Physics.Interactable = true;
ShootBullet.Physics.Collidable = true;
ShootBullet.Physics.Shape = GoblinXNA.Physics.ShapeType.Box;
ShootBullet.Physics.Mass = 60f;
ShootBullet.Physics.MaterialName = "Bullet";
ShootBullet.AddToPhysicsEngine = true;
// Assign the initial velocity to this shooting box
ShootBullet.Physics.InitialLinearVelocity = new Vector3(DirBullet.X * 80, DirBullet.Y * 80, DirBullet.Z * 50);
BulletTrans = new TransformNode();
BulletTrans.Translation = InitPos;
grdMarkerNode.AddChild(BulletTrans);
BulletTrans.AddChild(ShootBullet);
//Normal asignament
isvisible = true;
//Agrego Segundo desde que se creo
livetime = Convert.ToInt32(DateTime.Now.TimeOfDay.TotalSeconds) + BULLET_TIMELIVE;
}
private void CreateGround()
{
GeometryNode groundNode = new GeometryNode("Ground");
// We will use TexturedBox instead of regular Box class since we will need the
// texture coordinates elements for passing the vertices to the SimpleShadowShader
// we will be using
groundNode.Model = new TexturedBox(324, 180, 0.1f);
// Set this ground model to act as an occluder so that it appears transparent
groundNode.IsOccluder = true;
// Make the ground model to receive shadow casted by other objects with
// ShadowAttribute.ReceiveCast
groundNode.Model.ShadowAttribute = ShadowAttribute.ReceiveOnly;
// Assign a shadow shader for this model that uses the IShadowMap we assigned to the scene
groundNode.Model.Shader = new SimpleShadowShader(scene.ShadowMap);
Material groundMaterial = new Material();
groundMaterial.Diffuse = Color.Gray.ToVector4();
groundMaterial.Specular = Color.White.ToVector4();
groundMaterial.SpecularPower = 20;
groundNode.Material = groundMaterial;
groundMarkerNode.AddChild(groundNode);
}
public static GeometryNode AddModel(MarkerNode Marker, String Folder, String Model, bool IntMaterial, float Scala)
{
GeometryNode ObstNode;
if (Model == "null")
{
return(ObstNode = new GeometryNode());
}
ObstNode = Graphics3D.LoadModel("Models/" + Folder, Model, IntMaterial);
//define the Physic Material name
ObstNode.Physics.MaterialName = "Obstacle";
TransformNode parentTransNode = new TransformNode();
parentTransNode.Name = Model;
parentTransNode.Scale = new Vector3(Scala, Scala + 2, Scala);
parentTransNode.Rotation = Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), MathHelper.ToRadians(90));
//Add Rotation because Blender Axis
parentTransNode.AddChild(ObstNode);
// Add this box model node to the ground marker node
if (Marker != null)
{
Marker.AddChild(parentTransNode);
}
return(ObstNode);
}
public Block(MarkerNode markerNode, string[] names, float scale, ref GlobalVariables g)
{
global = g;
buildingsInBlocks = new List <Building>();
blockNode = markerNode;
blockTransNode = new TransformNode();
blockTransNode.Scale = Vector3.One * scale;
//////////////////////////////////////////////////////////////////////blockTransNode.Translation = new Vector3(0.0f, -64.25f, 0.0f);
//blockTransNode.Translation = new Vector3(0.0f, -64.25f, 0.0f); //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//blockTransNode.Translation = new Vector3(-33.5f, -54.25f, 0);
blockTransNode.Rotation = Quaternion.CreateFromAxisAngle(Vector3.UnitZ, MathHelper.PiOver2);
blockNode.AddChild(blockTransNode);
foreach (string s in names)
{
//Note, this needs to be changed so we are able to add different buildings to a marker
Building tempBuilding = new Building(s, ref global);
tempBuilding.loadBuildingModel(true, 1.0f); //change scale factor if necessary
buildingsInBlocks.Add(tempBuilding);
//blockTransNode.AddChild(tempBuilding.getBuildingNode()); /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// blockTransNode.Scale = new Vector3(blockTransNode.Scale.X * 1.0f, blockTransNode.Scale.Y * 1.0f, blockTransNode.Scale.Z * 1.0f);
// blockNode.AddChild(blockTransNode);
}
}
public Catalog(Scene s)
{
this.my_scene = s;
this.marker = new MarkerNode(my_scene.MarkerTracker, "palette_marker.xml");
this.changeMarker = new MarkerNode(my_scene.MarkerTracker, "palette_turn_marker.xml");
my_scene.RootNode.AddChild(marker);
my_scene.RootNode.AddChild(changeMarker);
library = new ItemLibrary("models.txt");
names2itemsInCatalog = new Dictionary <string, Item>();
names2itemsInRoom = new Dictionary <string, Item>();
item_list = library.getAllItems();
// this.objects = l;
int grid_x = 0;
int grid_y = 0;
foreach (Item i in item_list)
{
names2itemsInCatalog.Add(i.Label, i);
i.setGroupID(catalogGroupID);
i.Scale = new Vector3(9.0f, 9.0f, 9.0f) / i.Radius;
}
for (int i = cur_start; i < cur_end && i < item_list.Count; i++)
{
if (grid_x > 15)
{
grid_x = 0;
grid_y -= 15;
}
item_list[i].BindTo(marker);
item_list[i].MoveTo(new Vector3(grid_x, grid_y, 0));
grid_x += 15;
}
// Create a geometry node with a model of box
GeometryNode boxNode = new GeometryNode("Box");
boxNode.Model = new Box(30, 30, 0.1f);
TransformNode boxTransNode = new TransformNode();
boxTransNode.AddChild(boxNode);
boxTransNode.Translation += new Vector3(6, -6, -0.5f);
Material boxMat = new Material();
boxMat.Diffuse = Color.DimGray.ToVector4();
boxNode.Material = boxMat;
marker.AddChild(boxTransNode);
}
protected override void Draw(GameTime gameTime)
{
// Set the render target for rendering the AR scene
scene.SceneRenderTarget = arViewRenderTarget;
// Set the scene background size to be the size of the AR scene viewport
scene.BackgroundBound = arViewRect;
// Set the camera to be the AR camera
scene.CameraNode = arCameraNode;
// Associate the overlaid model with the ground marker for rendering it in AR scene
scene.RootNode.RemoveChild(overlayNode.Parent);
groundMarkerNode.AddChild(overlayNode.Parent);
// Don't render the marker board and camera representation
markerBoardGeom.Enabled = false;
vrCameraRepNode.Enabled = false;
// Show the video background
scene.ShowCameraImage = true;
// Render the AR scene
scene.Draw(gameTime.ElapsedGameTime, gameTime.IsRunningSlowly);
// Set the render target for rendering the VR scene
scene.SceneRenderTarget = vrViewRenderTarget;
// Set the scene background size to be the size of the VR scene viewport
scene.BackgroundBound = vrViewRect;
// Set the camera to be the VR camera
scene.CameraNode = vrCameraNode;
// Remove the overlaid model from the ground marker for rendering it in VR scene
groundMarkerNode.RemoveChild(overlayNode.Parent);
scene.RootNode.AddChild(overlayNode.Parent);
// Render the marker board and camera representation in VR scene
markerBoardGeom.Enabled = true;
vrCameraRepNode.Enabled = true;
// Update the transformation of the camera representation in VR scene based on the
// marker array transformation
if (groundMarkerNode.MarkerFound)
{
vrCameraRepTransNode.WorldTransformation = Matrix.Invert(groundMarkerNode.WorldTransformation);
}
// Do not show the video background
scene.ShowCameraImage = false;
// Re-traverse the scene graph since we have modified it, and render the VR scene
scene.RenderScene(false, true);
// Set the render target back to the frame buffer
State.Device.SetRenderTarget(null);
// Render the two textures rendered on the render targets
State.SharedSpriteBatch.Begin(SpriteSortMode.Immediate, BlendState.Opaque);
State.SharedSpriteBatch.Draw(arViewRenderTarget, arViewRect, Color.White);
State.SharedSpriteBatch.Draw(vrViewRenderTarget, vrViewRect, Color.White);
State.SharedSpriteBatch.End();
}
public static void CreateBall(MarkerNode Marker)
{
// Create a geometry node for Sphere
PrimitiveModel PsphereModel = new Sphere(15f, 20, 20);
// Create a material to apply to the sphere model
Material sphereMaterial = new Material();
sphereMaterial.Diffuse = new Vector4(0, 0.5f, 0, 1);
sphereMaterial.Specular = Color.White.ToVector4();
sphereMaterial.SpecularPower = 10;
GeometryNode sphereNode = new GeometryNode("Sphere");
//sphereNode.Model = new TexturedSphere(16, 20, 20);
sphereNode.Model = PsphereModel;
sphereNode.Material = sphereMaterial;
// Add this sphere model to the physics engine for collision detection
sphereNode.Physics.Interactable = true;
sphereNode.Physics.Collidable = true;
sphereNode.Physics.Shape = ShapeType.Sphere;
sphereNode.Physics.Mass = 30;
//sphereNode.Physics.ApplyGravity = false;
sphereNode.Physics.InitialLinearVelocity = new Vector3(30, 0, 0);
//sphereNode.Physics.MaterialName = "Sphere";
//sphereNode.Physics.ApplyGravity = true;
sphereNode.AddToPhysicsEngine = true;
// Make this sphere model cast and receive shadows
//sphereNode.Model.ShadowAttribute = ShadowAttribute.ReceiveCast;
// Assign a shadow shader for this model that uses the IShadowMap we assigned to the scene
//sphereNode.Model.Shader = new SimpleShadowShader(scene.ShadowMap);
TransformNode sphereTransNode = new TransformNode();
sphereTransNode.Translation = new Vector3(50, 0, 50);
// Now add the above nodes to the scene graph in the appropriate order.
// Note that only the nodes added below the marker node are affected by
// the marker transformation.
Marker.AddChild(sphereTransNode);
sphereTransNode.AddChild(sphereNode);
}
private void CreateGround()
{
groundNode = new GeometryNode("Ground");
// We will use TexturedBox instead of regular Box class since we will need the
// texture coordinates elements for passing the vertices to the SimpleShadowShader
// we will be using
groundNode.Model = new TexturedBox(800, 600, 0.1f);
// Set this ground model to act as an occluder so that it appears transparent
groundNode.IsOccluder = true;
// Make the ground model to receive shadow casted by other objects with
// ShadowAttribute.ReceiveCast
groundNode.Model.ShadowAttribute = ShadowAttribute.ReceiveOnly;
// Assign a shadow shader for this model that uses the IShadowMap we assigned to the scene
groundNode.Model.Shader = new SimpleShadowShader(scene.ShadowMap);
Material groundMaterial = new Material();
groundMaterial.Diffuse = Color.Gray.ToVector4();
groundMaterial.Specular = Color.White.ToVector4();
groundMaterial.SpecularPower = 20;
groundNode.Material = groundMaterial;
groundMarkerNode.AddChild(groundNode);
groundNode.AddToPhysicsEngine = true;
groundNode.Physics.Shape = ShapeType.Box;
groundNode.Physics.Collidable = true;
//groundNode.Physics.MaterialName = "Ground";
groundNode.Physics.ApplyGravity = false;
groundNode.Physics.Interactable = true;
groundNode.Physics.Manipulatable = true;
groundNode.Physics.Mass = 1;
groundNode.Physics.Pickable = true;
NewtonPhysics.CollisionPair CannonGroundColisionPair = new NewtonPhysics.CollisionPair(p1Tiro.obj.Physics, groundNode.Physics);
((NewtonPhysics)scene.PhysicsEngine).AddCollisionCallback(CannonGroundColisionPair, ballBounceGround);
}
//Let's set up marker tracking
public void CreateGround()
{
GeometryNode groundNode = new GeometryNode("Ground");
groundNode.Model = new Box(95, 59, 0.1f);
// Set this ground model to act as an occluder so that it appears transparent
groundNode.IsOccluder = true;
// Make the ground model to receive shadow casted by other objects with
// CastShadows set to true
groundNode.Model.ReceiveShadows = true;
Material groundMaterial = new Material();
groundMaterial.Diffuse = Color.Gray.ToVector4();
groundMaterial.Specular = Color.White.ToVector4();
groundMaterial.SpecularPower = 20;
groundNode.Material = groundMaterial;
groundMarkerNode.AddChild(groundNode);
}
private void CreateLights()
{
// Create a directional light source
LightSource lightSource = new LightSource();
lightSource.Direction = new Vector3(1, -1, -1);
lightSource.Diffuse = new Vector4(0.8f, 0.8f, 0.8f, 1);
lightSource.Specular = new Vector4(0.6f, 0.6f, 0.6f, 1);
// Create a light node to hold the light source
LightNode lightNode = new LightNode();
lightNode.CastShadows = true;
lightNode.LightProjection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4,
1, 1f, 500);
// Add an ambient component
lightNode.AmbientLightColor = new Vector4(0.3f, 0.3f, 0.3f, 1);
lightNode.LightSource = lightSource;
// Add this light node to the root node
groundMarkerNode.AddChild(lightNode);
}
public Graphics3D(MarkerNode MarkerNode, IShadowMap ShadowMap)
{
//Asignation Ground Node
this.groundMarkerNode = MarkerNode;
//Asignation Shadow Map
this.GShadowMap = ShadowMap;
//Add Big Parent for All Scenary Elements
parentTNodeGrd = new TransformNode();
parentTNodeGrd.Name = "Level";
groundMarkerNode.AddChild(parentTNodeGrd);
// Create a material for the model
BulletrMat = new Material();
BulletrMat.Diffuse = Color.Blue.ToVector4();
BulletrMat.Specular = Color.White.ToVector4();
BulletrMat.SpecularPower = 10;
//create Bullet Model
BulletModel = new TexturedBox(2.0f);
LoadLevel = false;
LoadCars = false;
}
private void CreateObjects()
{
// Create a marker node to track a ground marker array.
#if USE_PATTERN_MARKER
if (useSingleMarker)
{
groundMarkerNode = new MarkerNode(scene.MarkerTracker, "patt.hiro", 16, 16, markerSize, 0.7f);
}
else
{
groundMarkerNode = new MarkerNode(scene.MarkerTracker, "NyARToolkitGroundArray.xml",
NyARToolkitTracker.ComputationMethod.Average);
}
#else
groundMarkerNode = new MarkerNode(scene.MarkerTracker, "NyARToolkitIDGroundArray.xml",
NyARToolkitTracker.ComputationMethod.Average);
#endif
scene.RootNode.AddChild(groundMarkerNode);
//toolbarMarkerNode = new MarkerNode(scene.MarkerTracker, "NyARToolkitIDToolbar1.xml",
// NyARToolkitTracker.ComputationMethod.Average);
//scene.RootNode.AddChild(toolbarMarkerNode);
SynchronizedGeometryNode wall = new SynchronizedGeometryNode("wall");
wall.Model = new Box(WALL_WIDTH, WALL_HEIGHT, WALL_DEPTH);
wall.Model.ShowBoundingBox = true;
Material wallMaterial = new Material();
wallMaterial.Diffuse = Color.Gray.ToVector4();
wallMaterial.Ambient = Color.Blue.ToVector4();
wallMaterial.Emissive = Color.Green.ToVector4();
wall.Material = wallMaterial;
TransformNode wallTrans = new TransformNode();
wallTrans.Translation = new Vector3(0, 0, -20);
wall.Physics.Collidable = true;
wall.Physics.Interactable = true;
wall.AddToPhysicsEngine = true;
wall.Physics.Shape = GoblinXNA.Physics.ShapeType.Box;
wall.Physics.Mass = 0;
//scene.RootNode.AddChild(wall);
groundMarkerNode.AddChild(wallTrans);
wallTrans.AddChild(wall);
/////////////////////////////////////////////////////
SynchronizedGeometryNode ball = new SynchronizedGeometryNode("ball");
ball.Model = new Sphere(SPHERE_RADIUS, 20, 20);
ball.Model.ShowBoundingBox = true;
Material ballMaterial = new Material();
ballMaterial.Diffuse = Color.Yellow.ToVector4();
//ballMaterial.Ambient = Color.Maroon.ToVector4();
//ballMaterial.Emissive = Color.LightCoral.ToVector4();
ball.Material = ballMaterial;
TransformNode ballTrans = new TransformNode();
ballTrans.Translation = new Vector3(0, 0, 200);
//ball.Physics = new PhysicsObject(ball);
ball.Physics.Collidable = true;
ball.Physics.Interactable = true;
ball.Physics.AngularDamping = Vector3.Zero;
ball.Physics.LinearDamping = 0f;
ball.Physics.Shape = GoblinXNA.Physics.ShapeType.Sphere;
ball.Physics.Mass = 10;
ball.AddToPhysicsEngine = true;
ballTrans.AddChild(ball);
groundMarkerNode.AddChild(ballTrans);
/////////////////////////////////////////////////////////////////
paddleNode = new SynchronizedGeometryNode("paddle");
paddleNode.Model = new Box(PADDLE_HEIGHT, PADDLE_WIDTH, PADDLE_DEPTH);
Material paddleMaterial = new Material();
paddleMaterial.Diffuse = Color.Orange.ToVector4();
paddleMaterial.Specular = Color.White.ToVector4();
paddleMaterial.SpecularPower = 10;
paddleNode.Material = paddleMaterial;
paddleNode.Physics.Collidable = true;
paddleNode.Physics.Interactable = true;
paddleNode.Physics.Shape = GoblinXNA.Physics.ShapeType.Box;
paddleNode.Physics.Mass = 10;
paddleNode.AddToPhysicsEngine = true;
groundMarkerNode.AddChild(paddleNode);
}
private void dropBall()
{
ball_drop_delay = false;
ball_drop_countdown = 0;
ground_marker_node.AddChild(vball.getTransformNode());
}
private void createObjects()
{
// Create a marker node to track the ground array
ground_marker_node = new MarkerNode(scene.MarkerTracker, "SlimeGroundArray.xml", NyARToolkitTracker.ComputationMethod.Average);
scene.RootNode.AddChild(ground_marker_node);
InvisibleWall invisWallOne = new InvisibleWall(float.MaxValue, new Vector3(COURT_WIDTH, PLANAR_THICKNESS, COURT_LENGTH));
InvisibleWall invisWallTwo = new InvisibleWall(float.MaxValue, new Vector3(PLANAR_THICKNESS, COURT_LENGTH, COURT_LENGTH));
InvisibleWall invisWallThree = new InvisibleWall(float.MaxValue, new Vector3(COURT_WIDTH, PLANAR_THICKNESS, COURT_LENGTH));
InvisibleWall invisWallFour = new InvisibleWall(float.MaxValue, new Vector3(PLANAR_THICKNESS, COURT_LENGTH, COURT_LENGTH));
invisWallOne.translate(new Vector3(0, COURT_LENGTH / 2, COURT_LENGTH / 2));
invisWallTwo.translate(new Vector3(-(COURT_WIDTH / 2), 0, COURT_LENGTH / 2));
invisWallThree.translate(new Vector3(0, -(COURT_LENGTH / 2), COURT_LENGTH / 2));
invisWallFour.translate(new Vector3(COURT_WIDTH / 2, 0, COURT_LENGTH / 2));
// Add the walls onto the ground marker
ground_marker_node.AddChild(invisWallOne.getTransformNode());
ground_marker_node.AddChild(invisWallTwo.getTransformNode());
ground_marker_node.AddChild(invisWallThree.getTransformNode());
ground_marker_node.AddChild(invisWallFour.getTransformNode());
// Create the court
court = new Court(float.MaxValue, new Vector3(COURT_WIDTH, COURT_LENGTH, PLANAR_THICKNESS * 4));
// Initial translation
court.translate(new Vector3(0, 0, -14f));
// Add it to the scene
ground_marker_node.AddChild(court.getTransformNode());
// Time to create the net
Net net = new Net(float.MaxValue, new Vector3(COURT_WIDTH, PLANAR_THICKNESS, GROUND_MARKER_SIZE));
// Initial translation
net.translate(new Vector3(0, 0, 1f + (GROUND_MARKER_SIZE / 2)));
// Add it to the scene
ground_marker_node.AddChild(net.getTransformNode());
// Lets create the all important volleyball
if (selected_game_type == (int)game_types.opponent)
{
vball = new VolleyBall(1f, GROUND_MARKER_SIZE / 2f, bounceSound, true);
}
else
{
vball = new VolleyBall(1f, GROUND_MARKER_SIZE / 2f, bounceSound, false);
}
// Perform initial manipulations
vball.translate(PLAYER_BALL_START);
// Add it to the scene
ground_marker_node.AddChild(vball.getTransformNode());
// Create a marker node to track the paddle
player_marker_node = new MarkerNode(scene.MarkerTracker, "id511.xml", NyARToolkitTracker.ComputationMethod.Average);
scene.RootNode.AddChild(player_marker_node);
// Create the slime for the player
//player_slime = new Paddle(float.MaxValue, new Vector3(WAND_MARKER_SIZE * 1.5f, WAND_MARKER_SIZE * 1.5f, 3f), Color.Red.ToVector4());
player_slime = new Slime(float.MaxValue, GROUND_MARKER_SIZE, new Vector4(0.160784f, 0.501961f, 0.72549f, 1f), COURT_WIDTH / 2, -1 * COURT_WIDTH / 2, 0f, -1 * COURT_LENGTH / 2);
// Initial translation
player_slime.translate(PLAYER_SLIME_START);
//player_slime.setRotation(Quaternion.CreateFromAxisAngle(Vector3.UnitX, MathHelper.ToRadians(-PADDLE_ANGLE)));
//player_slime.setRotation(Quaternion.CreateFromAxisAngle(Vector3.UnitX, MathHelper.ToRadians(90)));
// Add it to the scene
ground_marker_node.AddChild(player_slime.getTransformNode());
// Create the slime for the opponent
//opponent_slime = new Paddle(float.MaxValue, new Vector3(WAND_MARKER_SIZE * 1.5f, WAND_MARKER_SIZE * 1.5f, 3f), Color.Purple.ToVector4());
opponent_slime = new Slime(float.MaxValue, GROUND_MARKER_SIZE, new Vector4(0.556863f, 0.266667f, 0.678431f, 1f), COURT_WIDTH / 2, -1 * COURT_WIDTH / 2, COURT_LENGTH / 2, 0f);
// Initial translation
opponent_slime.translate(OPPONENT_SLIME_START);
//opponent_slime.setRotation(Quaternion.CreateFromAxisAngle(Vector3.UnitX, MathHelper.ToRadians(PADDLE_ANGLE)));
//opponent_slime.setRotation(Quaternion.CreateFromAxisAngle(Vector3.UnitX, MathHelper.ToRadians(90)));
// Add it to the scene
ground_marker_node.AddChild(opponent_slime.getTransformNode());
// Create the laser sight target
target = new Target(TARGET_SIZE, Color.Red.ToVector4());
// perform initial translations
target.setTranslation(new Vector3(PLAYER_BALL_START.X, PLAYER_BALL_START.Y, (TARGET_SIZE / 2) + PLANAR_THICKNESS));
// Add it to the scene
ground_marker_node.AddChild(target.getTransformNode());
}
private void CreateObjects()
{
// Create a geometry node with a model of a sphere that will be overlaid on
// top of the ground marker array
GeometryNode sphereNode = new GeometryNode("Sphere");
// We will use TexturedSphere instead of regular Box class since we will need the
// texture coordinates elements for passing the vertices to the SimpleShadowShader
// we will be using
sphereNode.Model = new TexturedSphere(16, 20, 20);
// Add this sphere model to the physics engine for collision detection
sphereNode.AddToPhysicsEngine = true;
sphereNode.Physics.Shape = ShapeType.Sphere;
// Make this sphere model cast and receive shadows
sphereNode.Model.ShadowAttribute = ShadowAttribute.ReceiveCast;
// Assign a shadow shader for this model that uses the IShadowMap we assigned to the scene
sphereNode.Model.Shader = new SimpleShadowShader(scene.ShadowMap);
// Create a marker node to track a ground marker array.
groundMarkerNode = new MarkerNode(scene.MarkerTracker, "ALVARGroundArray.xml");
TransformNode sphereTransNode = new TransformNode();
sphereTransNode.Translation = new Vector3(0, 0, 50);
// Create a material to apply to the sphere model
Material sphereMaterial = new Material();
sphereMaterial.Diffuse = new Vector4(0, 0.5f, 0, 1);
sphereMaterial.Specular = Color.White.ToVector4();
sphereMaterial.SpecularPower = 10;
sphereNode.Material = sphereMaterial;
// Now add the above nodes to the scene graph in the appropriate order.
// Note that only the nodes added below the marker node are affected by
// the marker transformation.
scene.RootNode.AddChild(groundMarkerNode);
groundMarkerNode.AddChild(sphereTransNode);
sphereTransNode.AddChild(sphereNode);
// Create a geometry node with a model of a box that will be overlaid on
// top of the ground marker array initially. (When the toolbar marker array is
// detected, it will be overlaid on top of the toolbar marker array.)
boxNode = new GeometryNode("Box");
// We will use TexturedBox instead of regular Box class since we will need the
// texture coordinates elements for passing the vertices to the SimpleShadowShader
// we will be using
boxNode.Model = new TexturedBox(32.4f);
// Add this box model to the physics engine for collision detection
boxNode.AddToPhysicsEngine = true;
boxNode.Physics.Shape = ShapeType.Box;
// Make this box model cast and receive shadows
boxNode.Model.ShadowAttribute = ShadowAttribute.ReceiveCast;
// Assign a shadow shader for this model that uses the IShadowMap we assigned to the scene
boxNode.Model.Shader = new SimpleShadowShader(scene.ShadowMap);
// Create a marker node to track a toolbar marker array.
toolbarMarkerNode = new MarkerNode(scene.MarkerTracker, "ALVARToolbar.xml");
scene.RootNode.AddChild(toolbarMarkerNode);
// Create a material to apply to the box model
Material boxMaterial = new Material();
boxMaterial.Diffuse = new Vector4(0.5f, 0, 0, 1);
boxMaterial.Specular = Color.White.ToVector4();
boxMaterial.SpecularPower = 10;
boxNode.Material = boxMaterial;
// Add this box model node to the ground marker node
groundMarkerNode.AddChild(boxNode);
// Create a collision pair and add a collision callback function that will be
// called when the pair collides
NewtonPhysics.CollisionPair pair = new NewtonPhysics.CollisionPair(boxNode.Physics, sphereNode.Physics);
((NewtonPhysics)scene.PhysicsEngine).AddCollisionCallback(pair, BoxSphereCollision);
}
private void CreateObjects()
{
// Create a marker node to track a ground marker array.
groundMarkerNode = new MarkerNode(scene.MarkerTracker, "ALVARGroundArray.xml");
// Now add the above nodes to the scene graph in the appropriate order.
// Note that only the nodes added below the marker node are affected by
// the marker transformation.
scene.RootNode.AddChild(groundMarkerNode);
// Create a geometry node with a model of a box that will be overlaid on
// top of the ground marker array initially. (When the toolbar marker array is
// detected, it will be overlaid on top of the toolbar marker array.)
boxNode = new GeometryNode("Box");
// We will use TexturedBox instead of regular Box class since we will need the
// texture coordinates elements for passing the vertices to the SimpleShadowShader
// we will be using
boxNode.Model = new TexturedBox(100f, 100f, 5);
// Add this box model to the physics engine for collision detection
boxNode.AddToPhysicsEngine = true;
boxNode.Physics.Shape = ShapeType.Box;
// Make this box model cast and receive shadows
boxNode.Model.ShadowAttribute = ShadowAttribute.ReceiveCast;
// Assign a shadow shader for this model that uses the IShadowMap we assigned to the scene
boxNode.Model.Shader = new SimpleShadowShader(scene.ShadowMap);
// Create a marker node to track a toolbar marker array.
toolbarMarkerNode = new MarkerNode(scene.MarkerTracker, "ALVARToolbar.xml");
scene.RootNode.AddChild(toolbarMarkerNode);
// Create a material to apply to the box model
Material boxMaterial = new Material();
boxMaterial.Diffuse = new Vector4(0.5f, 0, 0, 1);
boxMaterial.Specular = Color.White.ToVector4();
boxMaterial.SpecularPower = 10;
boxNode.Material = boxMaterial;
// Add this box model node to the ground marker node
groundMarkerNode.AddChild(boxNode);
p1Tiro = new Tiro("p1Tiro", new Vector3(150, 0, 300), 1, 20, scene, groundMarkerNode);
groundMarkerNode.AddChild(p1Tiro.objTransfNode);
updatables.Add(p1Tiro);
NewtonPhysics.CollisionPair CannonPlayerColisionPair = new NewtonPhysics.CollisionPair(p1Tiro.obj.Physics, boxNode.Physics);
((NewtonPhysics)scene.PhysicsEngine).AddCollisionCallback(CannonPlayerColisionPair, playerShot);
targetNode = new GeometryNode("Box");
// We will use TexturedBox instead of regular Box class since we will need the
// texture coordinates elements for passing the vertices to the SimpleShadowShader
// we will be using
targetNode.Model = new TexturedBox(20f, 20f, 5);
// Add this box model to the physics engine for collision detection
targetNode.AddToPhysicsEngine = true;
targetNode.Physics.Shape = ShapeType.Box;
// Make this box model cast and receive shadows
targetNode.Model.ShadowAttribute = ShadowAttribute.ReceiveCast;
// Assign a shadow shader for this model that uses the IShadowMap we assigned to the scene
targetNode.Model.Shader = new SimpleShadowShader(scene.ShadowMap);
Material targetMaterial = new Material();
targetMaterial.Diffuse = Color.Indigo.ToVector4();
targetMaterial.Specular = Color.DarkGoldenrod.ToVector4();
targetMaterial.SpecularPower = 10;
targetNode.Material = targetMaterial;
groundMarkerNode.AddChild(targetNode);
NewtonPhysics.CollisionPair PlayerScoreColisionPair = new NewtonPhysics.CollisionPair(p1Tiro.obj.Physics, targetNode.Physics);
((NewtonPhysics)scene.PhysicsEngine).AddCollisionCallback(PlayerScoreColisionPair, playerScore);
}
public void CreateObjects()
{
floor = new GeometryNode("Floor");//floor
floor.Model = new Box(floorBreadth, floorLength, 0.0001f);
floor.Model.ReceiveShadows = true;
floorTransNode = new TransformNode();
floorTransNode.Translation = new Vector3(floorBreadth / 3, -floorLength / 2, 0); // 0 0
floor.Physics.Collidable = true;
floor.Physics.Pickable = true;
floor.GroupID = roomGroupID;
floor.Physics.Shape = GoblinXNA.Physics.ShapeType.Box;
floor.AddToPhysicsEngine = true;
//grid1.IsOccluder = true;
//Material for the room floor
floorMaterial = new Material();
Vector4 alpha = Color.Gray.ToVector4();
Vector3 tempAlpha = new Vector3(alpha.X, alpha.Y, alpha.Z);
floorMaterial.Diffuse = new Vector4(tempAlpha, 0.2f);
floorMaterial.Specular = Color.White.ToVector4();
floorMaterial.SpecularPower = 20;
floor.Material = floorMaterial;
//Material for the walls
wallsMaterial = new Material();
wallsMaterial.Diffuse = Color.Gray.ToVector4();
wallsMaterial.Specular = Color.White.ToVector4();
wallsMaterial.SpecularPower = 20;
frontWall = new GeometryNode("Front wall");//front wall
frontWall.Model = new Box(floorBreadth, floorLength, 1);
frontWallTransNode = new TransformNode();
frontWallTransNode.Translation = new Vector3(floorBreadth / 3, 0, floorLength / 2); // 1 0
frontWallTransNode.Rotation = Quaternion.CreateFromAxisAngle(Vector3.UnitX, MathHelper.ToRadians(90));
frontWall.Material = wallsMaterial;
frontWall.GroupID = roomGroupID;
frontWall.AddToPhysicsEngine = true;
frontWall.Physics.Collidable = true;
frontWall.Physics.Pickable = true;
frontWall.Physics.Shape = GoblinXNA.Physics.ShapeType.Box;
rightWall = new GeometryNode("Right wall");//right side wall
rightWall.Model = new Box(floorBreadth, floorLength, 1);
rightWallTransNode = new TransformNode();
rightWallTransNode.Translation = new Vector3(floorBreadth * 4.2f / 5, -floorLength / 2, floorLength / 2); // -1 0
rightWallTransNode.Rotation = Quaternion.CreateFromAxisAngle(Vector3.UnitY, MathHelper.ToRadians(90));
rightWall.Material = wallsMaterial;
rightWall.AddToPhysicsEngine = true;
rightWall.GroupID = roomGroupID;
rightWall.Physics.Pickable = true;
rightWall.Physics.Collidable = true;
rightWall.Physics.Shape = GoblinXNA.Physics.ShapeType.Box;
// Create a marker node to track a ground marker array.
#if USE_ARTAG
groundMarkerNode = new MarkerNode(scene.MarkerTracker, "ground");
// Since we expect that the ground marker array won't move very much, we use a
// small smoothing alpha.
//groundMarkerNode.Smoother = new DESSmoother(0.2f, 0.1f, 1, 1);
#else
// groundMarkerNode = new MarkerNode(scene.MarkerTracker, "ALVARGroundArray.xml");
groundMarkerNode = new MarkerNode(this.scene.MarkerTracker, "ALVARConfig.txt");
#endif
// Now add the above nodes to the scene graph in the appropriate order.
// Note that only the nodes added below the marker node are affected by
// the marker transformation.
scene.RootNode.AddChild(groundMarkerNode);
//Change the toolbar.txt config file. As of now, toolbar has markers included in the long stretch-alvarConfig.txt
worldInMiniatureMarkerNode = new MarkerNode(scene.MarkerTracker, "ALVARConfig32_33.txt");
scene.RootNode.AddChild(worldInMiniatureMarkerNode);
groundMarkerNode.AddChild(floorTransNode);
floorTransNode.AddChild(floor);
groundMarkerNode.AddChild(frontWallTransNode);
frontWallTransNode.AddChild(frontWall);
groundMarkerNode.AddChild(rightWallTransNode);
rightWallTransNode.AddChild(rightWall);
}
public void Draw(TimeSpan elapsedTime)
{
// Reset the XNA viewport to our centered and resized viewport
State.Device.Viewport = viewport;
// Set the render target for rendering the AR scene
scene.SceneRenderTarget = arViewRenderTarget;
scene.BackgroundColor = Color.Black;
// Set the scene background size to be the size of the AR scene viewport
scene.BackgroundBound = arViewRect;
// Set the camera to be the AR camera
scene.CameraNode = arCameraNode;
// Associate the overlaid model with the ground marker for rendering it in AR scene
scene.RootNode.RemoveChild(overlayRoot);
groundMarkerNode.AddChild(overlayRoot);
// Don't render the marker board and camera representation
markerBoardGeom.Enabled = false;
vrCameraRepNode.Enabled = false;
// Show the video background
scene.BackgroundTexture = videoTexture;
// Render the AR scene
scene.Draw(elapsedTime, false);
// Set the render target for rendering the VR scene
scene.SceneRenderTarget = vrViewRenderTarget;
scene.BackgroundColor = Color.CornflowerBlue;
// Set the scene background size to be the size of the VR scene viewport
scene.BackgroundBound = vrViewRect;
// Set the camera to be the VR camera
scene.CameraNode = vrCameraNode;
// Remove the overlaid model from the ground marker for rendering it in VR scene
groundMarkerNode.RemoveChild(overlayRoot);
scene.RootNode.AddChild(overlayRoot);
// Render the marker board and camera representation in VR scene
markerBoardGeom.Enabled = true;
vrCameraRepNode.Enabled = true;
// Update the transformation of the camera representation in VR scene based on the
// marker array transformation
if (groundMarkerNode.MarkerFound)
{
vrCameraRepTransNode.WorldTransformation = Matrix.Invert(groundMarkerNode.WorldTransformation);
}
// Do not show the video background
scene.BackgroundTexture = null;
// Re-traverse the scene graph since we have modified it, and render the VR scene
scene.RenderScene(false, true);
// Adjust the viewport to be centered
arViewRect.X += viewport.X;
vrViewRect.X += viewport.X;
// Set the render target back to the frame buffer
State.Device.SetRenderTarget(null);
State.Device.Clear(Color.Black);
// Render the two textures rendered on the render targets
State.SharedSpriteBatch.Begin(SpriteSortMode.Immediate, BlendState.Opaque);
State.SharedSpriteBatch.Draw(arViewRenderTarget, arViewRect, Color.White);
State.SharedSpriteBatch.Draw(vrViewRenderTarget, vrViewRect, Color.White);
State.SharedSpriteBatch.End();
// Reset the adjustments
arViewRect.X -= viewport.X;
vrViewRect.X -= viewport.X;
}