// -------------------------------------------------------------------------------
//
// -------------------------------------------------------------------------------
public static bool IsOppositeDirection(Vector3 v1, Vector3 v2)
{
DirectionType dir1 = Vector3Helper.CardinalDirection(v1);
DirectionType dir2 = Vector3Helper.CardinalDirection(v2);
return(IsOppositeDirection(dir1, dir2));
}
public void Read(Stream s)
{
var r = new BinaryReader(s);
Flags = r.ReadUInt32();
IndexX = r.ReadUInt32();
IndexY = r.ReadUInt32();
Layers = r.ReadUInt32();
DoodadRefs = r.ReadUInt32();
OffsetMCVT = r.ReadUInt32();
OffsetMCNR = r.ReadUInt32();
OffsetMCLY = r.ReadUInt32();
OffsetMCRF = r.ReadUInt32();
OffsetMCAL = r.ReadUInt32();
SizeMCAL = r.ReadUInt32();
OffsetMCSH = r.ReadUInt32();
SizeMCSH = r.ReadUInt32();
AreaId = r.ReadUInt32();
MapObjectRefs = r.ReadUInt32();
Holes = r.ReadUInt32();
LowQualityTextureMap = new uint[4];
for (int i = 0; i < 4; i++)
{
LowQualityTextureMap[i] = r.ReadUInt32();
}
PredTex = r.ReadUInt32();
NumberEffectDoodad = r.ReadUInt32();
OffsetMCSE = r.ReadUInt32();
SoundEmitters = r.ReadUInt32();
OffsetMCLQ = r.ReadUInt32();
SizeMCLQ = r.ReadUInt32();
Position = Vector3Helper.Read(s);
OffsetMCCV = r.ReadUInt32();
}
public static WorldModelHeader Read(Stream s)
{
var r = new BinaryReader(s);
var ret = new WorldModelHeader();
ret.CountMaterials = r.ReadUInt32();
ret.CountGroups = r.ReadUInt32();
ret.CountPortals = r.ReadUInt32();
ret.CountLights = r.ReadUInt32();
ret.CountModels = r.ReadUInt32();
ret.CountDoodads = r.ReadUInt32();
ret.CountSets = r.ReadUInt32();
ret.AmbientColor = r.ReadUInt32();
ret.WmoId = r.ReadUInt32();
ret.BoundingBox = new Vector3[2];
ret.BoundingBox[0] = Vector3Helper.Read(s);
ret.BoundingBox[1] = Vector3Helper.Read(s);
ret.ExtraFlag = r.ReadUInt16();
/*
* _t flag_attenuate_vertices_based_on_distance_to_portal : 1;
* uint16_t flag_skip_base_color : 1; // do not add base (ambient) color (of MOHD) to MOCVs. apparently does more, e.g. required for multiple MOCVs
* uint16_t flag_liquid_related : 1; // fills the whole WMO with water (used for underwater WMOs). (possibly - LiquidType related, see below in the MLIQ).
* uint16_t flag_has_some_outdoor_group : 1; // possibly - has some group that is outdoors
* uint16_t Flag_Lod : 1;
*/
ret.numLod = r.ReadUInt16();
return(ret);
}
public void SetParameters(Material material)
{
if (material.InternalEffect != null)
{
if (material.InternalEffect is BasicEffect)
{
BasicEffect be = (BasicEffect)material.InternalEffect;
alphaEffect.Alpha = be.Alpha;
alphaEffect.DiffuseColor = be.DiffuseColor;
alphaEffect.Texture = be.Texture;
alphaEffect.VertexColorEnabled = be.VertexColorEnabled;
}
else
{
Log.Write("Passed internal effect is not BasicEffect, so we can not apply the " +
"effect to this shader", Log.LogLevel.Warning);
}
}
else
{
alphaEffect.Alpha = material.Diffuse.W;
alphaEffect.DiffuseColor = Vector3Helper.GetVector3(material.Diffuse);
alphaEffect.Texture = material.Texture;
}
}
protected override void Initialize()
{
base.Initialize();
textureName = "fire";
duration = TimeSpan.FromSeconds(2);
durationRandomness = 1;
minHorizontalVelocity = 0;
maxHorizontalVelocity = 15;
minVerticalVelocity = -10;
maxVerticalVelocity = 10;
// Set gravity upside down, so the flames will 'fall' upward.
gravity = Vector3Helper.Get(0, 15, 0);
minColor = new Color(0, 0, 0, 10);
maxColor = new Color(255, 255, 255, 40);
minStartSize = 5;
maxStartSize = 10;
minEndSize = 10;
maxEndSize = 40;
blendState = BlendState.Additive;
}
protected override void Initialize()
{
base.Initialize();
textureName = "smoke";
duration = TimeSpan.FromSeconds(4);
minHorizontalVelocity = 0;
maxHorizontalVelocity = 50;
minVerticalVelocity = -10;
maxVerticalVelocity = 50;
gravity = Vector3Helper.Get(0, -20, 0);
endVelocity = 0;
minColor = Color.LightGray;
maxColor = Color.White;
minRotateSpeed = -2;
maxRotateSpeed = 2;
minStartSize = 10;
maxStartSize = 10;
minEndSize = 100;
maxEndSize = 200;
}
public void Read(Stream s)
{
var r = new BinaryReader(s);
Magic = r.ReadBytes(4);
Version = r.ReadUInt32();
LengthModelName = r.ReadUInt32();
OffsetName = r.ReadUInt32();
ModelFlags = r.ReadUInt32();
CountGlobalSequences = r.ReadUInt32();
OffsetGlobalSequences = r.ReadUInt32();
CountAnimations = r.ReadUInt32();
OffsetAnimations = r.ReadUInt32();
CountAnimationLookup = r.ReadUInt32();
OffsetAnimationLookup = r.ReadUInt32();
CountBones = r.ReadUInt32();
OffsetBones = r.ReadUInt32();
CountKeyBoneLookup = r.ReadUInt32();
OffsetKeyBoneLookup = r.ReadUInt32();
CountVertices = r.ReadUInt32();
OffsetVertices = r.ReadUInt32();
CountViews = r.ReadUInt32();
CountColors = r.ReadUInt32();
OffsetColors = r.ReadUInt32();
CountTextures = r.ReadUInt32();
OffsetTextures = r.ReadUInt32();
CountTransparency = r.ReadUInt32();
OffsetTransparency = r.ReadUInt32();
CountUvAnimation = r.ReadUInt32();
OffsetUvAnimation = r.ReadUInt32();
CountTexReplace = r.ReadUInt32();
OffsetTexReplace = r.ReadUInt32();
CountRenderFlags = r.ReadUInt32();
OffsetRenderFlags = r.ReadUInt32();
CountBoneLookup = r.ReadUInt32();
OffsetBoneLookup = r.ReadUInt32();
CountTexLookup = r.ReadUInt32();
OffsetTexLookup = r.ReadUInt32();
CountTexUnits = r.ReadUInt32();
OffsetTexUnits = r.ReadUInt32();
CountTransLookup = r.ReadUInt32();
OffsetTransLookup = r.ReadUInt32();
CountUvAnimLookup = r.ReadUInt32();
OffsetUvAnimLookup = r.ReadUInt32();
VertexBox = new Vector3[2];
VertexBox[0] = Vector3Helper.Read(s);
VertexBox[1] = Vector3Helper.Read(s);
VertexRadius = r.ReadSingle();
BoundingBox = new Vector3[2];
BoundingBox[0] = Vector3Helper.Read(s);
BoundingBox[1] = Vector3Helper.Read(s);
BoundingRadius = r.ReadSingle();
CountBoundingTriangles = r.ReadUInt32();
OffsetBoundingTriangles = r.ReadUInt32();
CountBoundingVertices = r.ReadUInt32();
OffsetBoundingVertices = r.ReadUInt32();
CountBoundingNormals = r.ReadUInt32();
OffsetBoundingNormals = r.ReadUInt32();
}
public void AddTorque(IPhysicsObject physObj, float timeStep, Vector3 torque)
{
if (!objectIDs.ContainsKey(physObj))
{
return;
}
HavokDllBridge.add_torque(objectIDs[physObj], timeStep, Vector3Helper.ToFloats(torque));
}
public void SetAngularVelocity(IPhysicsObject physObj, Vector3 velocity)
{
if (!objectIDs.ContainsKey(physObj))
{
return;
}
HavokDllBridge.set_angular_velocity(objectIDs[physObj], Vector3Helper.ToFloats(velocity));
}
public void Read(Stream s)
{
var r = new BinaryReader(s);
var startingOffset = s.Position;
Flags = (MapChunkHeaderFlags)r.ReadUInt32();
IndexX = r.ReadUInt32();
IndexY = r.ReadUInt32();
Layers = r.ReadUInt32();
DoodadRefs = r.ReadUInt32();
HighResHoleL = r.ReadUInt32();
HighResHoleH = r.ReadUInt32();
OffsetMCLY = r.ReadUInt32();
OffsetMCRF = r.ReadUInt32();
OffsetMCAL = r.ReadUInt32();
SizeMCAL = r.ReadUInt32();
OffsetMCSH = r.ReadUInt32();
SizeMCSH = r.ReadUInt32();
AreaId = r.ReadUInt32();
MapObjectRefs = r.ReadUInt32();
LowResHoles = r.ReadUInt16();
HolesAlign = r.ReadUInt16();
LowQualityTextureMap = new uint[4];
for (int i = 0; i < 4; i++)
{
LowQualityTextureMap[i] = r.ReadUInt32();
}
PredTex = r.ReadUInt32();
NumberEffectDoodad = r.ReadUInt32();
OffsetMCSE = r.ReadUInt32();
SoundEmitters = r.ReadUInt32();
OffsetMCLQ = r.ReadUInt32();
SizeMCLQ = r.ReadUInt32();
Position = Vector3Helper.Read(r.BaseStream);
OffsetMCCV = r.ReadUInt32();
OffsetMCLV = r.ReadUInt32();
unused = r.ReadUInt32();
//string sigString = "MCVT";
//var arr = Encoding.ASCII.GetBytes(sigString);
//Array.Reverse(arr);
//uint sigInt = BitConverter.ToUInt32(arr, 0);
long currentPos = s.Position;
var sig = r.ReadUInt32();
var size = r.ReadUInt32();
while (sig != 0x4D435654 && s.CanRead) // 0x4D435654 = MCVT reversed
{
Console.WriteLine("I had to read more data");
s.Position = currentPos + size;
currentPos = s.Position;
sig = r.ReadUInt32();
size = r.ReadUInt32();
}
MCVTDataOffsetComputed = (uint)(s.Position - startingOffset);
}
// -------------------------------------------------------------------------------
//
// -------------------------------------------------------------------------------
private void OnTurned()
{
facingDirection = Vector3Helper.CardinalDirection(transform.forward);
if (!Finder.battle.InBattle)
{
enabled = true;
}
changedDirection = true;
OnPlayerTurned();
}
public virtual void SetParameters(GoblinXNA.Graphics.Environment environment)
{
basicEffect.FogEnabled = environment.FogEnabled;
if (environment.FogEnabled)
{
basicEffect.FogStart = environment.FogStartDistance;
basicEffect.FogEnd = environment.FogEndDistance;
basicEffect.FogColor = Vector3Helper.GetVector3(environment.FogColor);
}
}
private void ReadBoundingNormals(Stream s)
{
s.Seek(Header.OffsetBoundingNormals, SeekOrigin.Begin);
Normals = new Vector3[Header.CountBoundingNormals];
for (int i = 0; i < Header.CountBoundingNormals; i++)
{
Normals[i] = Vector3Helper.Read(s);
}
}
private void ReadVertices(Stream s)
{
s.Seek(Header.OffsetBoundingVertices, SeekOrigin.Begin);
Vertices = new Vector3[Header.CountBoundingVertices];
for (int i = 0; i < Header.CountBoundingVertices; i++)
{
Vertices[i] = Vector3Helper.Read(s);
}
}
public void SetParameters(Material material)
{
if (material.InternalEffect != null)
{
if (material.InternalEffect is BasicEffect)
{
internalEffect = (BasicEffect)material.InternalEffect;
internalEffect.Alpha = originalAlphas[internalEffect] * material.Diffuse.W;
if (MixMaterialDiffuseWithTexture)
{
internalEffect.DiffuseColor *= Vector3Helper.GetVector3(material.Diffuse);
}
if (lightsChanged)
{
internalEffect.LightingEnabled = basicEffect.LightingEnabled;
internalEffect.PreferPerPixelLighting = basicEffect.PreferPerPixelLighting;
internalEffect.AmbientLightColor = basicEffect.AmbientLightColor;
if (basicEffect.LightingEnabled)
{
DirectionalLight[] lights = { internalEffect.DirectionalLight0,
internalEffect.DirectionalLight1, internalEffect.DirectionalLight2 };
int numLightSource = lightSources.Count;
for (int i = 0; i < numLightSource; i++)
{
lights[i].Enabled = true;
lights[i].DiffuseColor = Vector3Helper.GetVector3(lightSources[i].Diffuse);
lights[i].Direction = lightSources[i].Direction;
lights[i].SpecularColor = Vector3Helper.GetVector3(lightSources[i].Specular);
}
for (int i = numLightSource; i < MaxLights; i++)
{
lights[i].Enabled = false;
}
}
}
}
else
{
Log.Write("Passed internal effect is not BasicEffect, so we can not apply the " +
"effect to this shader", Log.LogLevel.Warning);
}
}
else
{
basicEffect.Alpha = material.Diffuse.W;
basicEffect.DiffuseColor = Vector3Helper.GetVector3(material.Diffuse);
basicEffect.SpecularColor = Vector3Helper.GetVector3(material.Specular);
basicEffect.EmissiveColor = Vector3Helper.GetVector3(material.Emissive);
basicEffect.SpecularPower = material.SpecularPower;
basicEffect.TextureEnabled = material.HasTexture;
basicEffect.Texture = material.Texture;
}
}
public Vector3 GetPosition(IPhysicsObject physObj)
{
if (!objectIDs.ContainsKey(physObj))
{
return(Vector3.Zero);
}
float[] position = new float[3];
HavokDllBridge.get_body_position(objectIDs[physObj], position);
return(Vector3Helper.FromFloats(position));
}
public void Read(Stream s)
{
var r = new BinaryReader(s);
MmidIndex = r.ReadUInt32();
UniqueId = r.ReadUInt32();
Position = Vector3Helper.Read(s);
Rotation = Vector3Helper.Read(s);
DecimalScale = r.ReadUInt16();
Flags = r.ReadUInt16();
}
public void InitializePhysics()
{
Vector3 g = info.Gravity * info.GravityDirection;
if (!HavokDllBridge.init_world(Vector3Helper.ToFloats(g), info.WorldSize,
info.CollisionTolerance, info.HavokSimulationType, info.HavokSolverType,
info.FireCollisionCallbacks, info.EnableDeactivation))
{
throw new GoblinException("Failed to initialize Havok physics");
}
}
public void ApplyHardKeyFrame(IPhysicsObject physObj, Vector3 newPos, Quaternion newRot, float timeStep)
{
if (!objectIDs.ContainsKey(physObj))
{
return;
}
float[] pos = Vector3Helper.ToFloats(ref newPos);
float[] rot = { newRot.X, newRot.Y, newRot.Z, newRot.W };
HavokDllBridge.apply_hard_keyframe(objectIDs[physObj], pos, rot, timeStep);
}
// -------------------------------------------------------------------------------
// LoadFloor
// -------------------------------------------------------------------------------
public void LoadFloor()
{
interactables.Clear();
if (currentDungeonConfig != null)
{
map = LoadDungeon(currentDungeonConfig);
}
if (map != null)
{
LoadMapConfig();
ClearMap();
for (int x = 0; x < map.Size.x; x++)
{
for (int y = 0; y < map.Size.y; y++)
{
ScriptableTile tile = map.GetTile(x, y);
if (tile is DungeonTileStart)
{
startPos = new Vector3(x, Finder.navi.baseHeightOffset, y);
startDir = Vector3Helper.CardinalDirection(((DungeonTileStart)tile).facingDirection);
CreateDungeonFloor(x, y, false, ((DungeonTileStart)tile).floorPrefab);
CreateDungeonCeiling(x, y, ((DungeonTileStart)tile).ceilingPrefab);
}
else if (tile is DungeonTileWall)
{
CreateDungeonFloor(x, y, true, ((DungeonTileWall)tile).floorPrefab);
CreateDungeonWall(x, y, ((DungeonTileWall)tile));
CreateDungeonCeiling(x, y, ((DungeonTileWall)tile).ceilingPrefab);
}
else if (tile is DungeonTileFloor)
{
CreateDungeonFloor(x, y, true, ((DungeonTileFloor)tile).floorPrefab, (DungeonTileFloor)tile);
CreateDungeonCeiling(x, y, ((DungeonTileFloor)tile).ceilingPrefab, (DungeonTileFloor)tile);
}
else if (tile is DungeonTileEvent)
{
CreateDungeonObject(x, y, (DungeonTileEvent)tile);
CreateDungeonFloor(x, y, false, ((DungeonTileEvent)tile).floorPrefab);
CreateDungeonCeiling(x, y, ((DungeonTileEvent)tile).ceilingPrefab);
}
}
}
}
else
{
throw new InvalidOperationException("tile map could not be loaded from map config!");
}
}
public static LiquidHeader Read(Stream s)
{
var ret = new LiquidHeader();
var r = new BinaryReader(s);
ret.CountXVertices = r.ReadUInt32();
ret.CountYVertices = r.ReadUInt32();
ret.Width = r.ReadUInt32();
ret.Height = r.ReadUInt32();
ret.BaseLocation = Vector3Helper.Read(s);
ret.MaterialId = r.ReadUInt16();
return(ret);
}
// -------------------------------------------------------------------------------
// CreateDungeonObject
// -------------------------------------------------------------------------------
private void CreateDungeonObject(int x, int y, DungeonTileEvent tile)
{
if (tile != null)
{
GameObject instance = (GameObject)GameObject.Instantiate(tile.objectPrefab);
if (Vector3Helper.CardinalDirection(tile.facingDirection) != Vector3.zero)
{
instance.transform.forward = Vector3Helper.CardinalDirection(tile.facingDirection);
}
instance.transform.position = new Vector3(x, tile.offsetHeight, y);
if (tile.facingDirection != DirectionType.None && !tile.interactFromBothSides)
{
instance.transform.position -= instance.transform.forward / 3;
}
instance.transform.parent = MapContainer;
instance.name = string.Format("{0}_{1}", x, y);
interactables.Add(new Interactable {
FacePlayer = tile.facePlayer, transform = instance.transform, ID = x.ToString() + y.ToString()
});
DungeonObjectEvent co = instance.GetComponent <DungeonObjectEvent>();
co.tile = tile;
co.Location = new Location {
template = currentDungeonConfig, X = x, Y = y
};
if (Finder.party.InteractedObjects.Any(i => i.Location.Equals(co.Location)))
{
co.SetInteraction(true);
}
if (tile.StartsDeactivated || Finder.party.DeactivatedObjects.Any(i => i.Location.Equals(co.Location)))
{
co.Deactivate();
}
else
{
co.Activate();
}
}
else
{
Debug.LogErrorFormat("Error: No tile defined at position: {0}, {1}", x, y);
}
}
// ===============================================================================
// TELEPORT & MOVEMENT
// ===============================================================================
// -------------------------------------------------------------------------------
// TeleportPlayer
// -------------------------------------------------------------------------------
public void TeleportPlayer(Location location)
{
if (location == null || location.locationType == LocationType.None)
{
return;
}
if (location.template == null)
{
location.template = location.targetMap;
}
Finder.ui.DeactivateAll();
// -- Teleport to Worldmap
if (location.locationType == LocationType.Worldmap)
{
WarpWorldmap();
return;
}
// -- Teleport to Town
if (location.locationType == LocationType.Town)
{
WarpTown((TemplateMetaTown)location.template);
return;
}
// -- Teleport to Outro
if (location.locationType == LocationType.Outro)
{
WarpOutro();
return;
}
// -- Teleport to Dungeon
if (location.locationType == LocationType.Dungeon)
{
WarpDungeon((TemplateMetaDungeon)location.template, false);
Finder.party.transform.position = new Vector3(location.X, Finder.navi.baseHeightOffset, location.Y);
if (Vector3Helper.CardinalDirection(location.facingDirection) != Vector3.zero)
{
Finder.party.transform.forward = Vector3Helper.CardinalDirection(location.facingDirection);
}
Finder.navi.enabled = true;
}
}
// -------------------------------------------------------------------------------
//
// -------------------------------------------------------------------------------
public void OnMoved()
{
Finder.audio.PlaySFX(SFX.Footstep);
NormalizeTransform();
Finder.map.UpdateInteractableDirection();
Finder.party.MapExplorationInfo.AddExploredSpace(Finder.map.MapName, new Vector2(Finder.party.transform.position.x, Finder.party.transform.position.z));
facingDirection = Vector3Helper.CardinalDirection(transform.forward);
if (!Finder.battle.InBattle)
{
enabled = true;
}
changedDirection = false;
OnPlayerMoved();
}
private static CustomMesh CreateLayer(Vector2 dimension)
{
CustomMesh mesh = new CustomMesh();
VertexPositionNormalTexture[] vertices = new VertexPositionNormalTexture[4];
Vector2 halfExtent = dimension / 2;
Vector3 v0 = Vector3Helper.Get(-halfExtent.X, 0, -halfExtent.Y);
Vector3 v1 = Vector3Helper.Get(-halfExtent.X, 0, halfExtent.Y);
Vector3 v2 = Vector3Helper.Get(halfExtent.X, 0, halfExtent.Y);
Vector3 v3 = Vector3Helper.Get(halfExtent.X, 0, -halfExtent.Y);
vertices[0].Position = v0;
vertices[1].Position = v1;
vertices[2].Position = v2;
vertices[3].Position = v3;
for (int i = 0; i < vertices.Length; i++)
{
vertices[i].Normal = Vector3.UnitY;
}
vertices[1].TextureCoordinate = new Vector2(0, 1);
vertices[0].TextureCoordinate = new Vector2(0, 0);
vertices[2].TextureCoordinate = new Vector2(1, 1);
vertices[3].TextureCoordinate = new Vector2(1, 0);
mesh.VertexDeclaration = new VertexDeclaration(State.Device,
VertexPositionNormalTexture.VertexElements);
mesh.VertexBuffer = new VertexBuffer(State.Device,
VertexPositionNormalTexture.SizeInBytes * vertices.Length, BufferUsage.None);
mesh.VertexBuffer.SetData(vertices);
short[] indices = new short[6];
indices[0] = 0; indices[1] = 2; indices[2] = 1;
indices[3] = 2; indices[4] = 0; indices[5] = 3;
mesh.IndexBuffer = new IndexBuffer(State.Device, typeof(short), 6,
BufferUsage.None);
mesh.IndexBuffer.SetData(indices);
mesh.SizeInBytes = VertexPositionNormalTexture.SizeInBytes;
mesh.NumberOfVertices = 4;
mesh.NumberOfPrimitives = 2;
return(mesh);
}
void Update()
{
if (this.checkAngle)
{
float angle = Vector3Helper.GetAngleInRadians(Player.Instance.transform.forward, this.transform.position - Player.Instance.transform.position, Vector3.up);
if (Mathf.Abs(angle) < MathConstants.Rad15Deg)
{
this.ActivateInteraction();
}
else
{
this.DeactivateInteraction();
}
}
}
public static DoodadInstance Read(Stream s)
{
var r = new BinaryReader(s);
var ret = new DoodadInstance();
ret.FileOffset = r.ReadUInt32();
ret.Position = Vector3Helper.Read(s);
ret.QuatW = r.ReadSingle();
ret.QuatX = r.ReadSingle();
ret.QuatY = r.ReadSingle();
ret.QuatZ = r.ReadSingle();
ret.Scale = r.ReadSingle();
ret.LightColor = r.ReadUInt32();
return(ret);
}
public BoundingBox GetAxisAlignedBoundingBox(IPhysicsObject physObj)
{
if (!objectIDs.ContainsKey(physObj))
{
return(new BoundingBox());
}
float[] min = new float[3];
float[] max = new float[3];
HavokDllBridge.get_AABB(objectIDs[physObj], min, max);
Vector3Helper.FromFloats(min, out tmpVec1);
Vector3Helper.FromFloats(max, out tmpVec2);
return(new BoundingBox(tmpVec1, tmpVec2));
}
public void SetParameters(Material material)
{
if (material.InternalEffect != null)
{
if (material.InternalEffect is SkinnedEffect)
{
internalEffect = (SkinnedEffect)material.InternalEffect;
internalEffect.Alpha = originalAlphas[alphaIndexer] * material.Diffuse.W;
internalEffect.PreferPerPixelLighting = skinnedEffect.PreferPerPixelLighting;
internalEffect.AmbientLightColor = skinnedEffect.AmbientLightColor;
if (lightsChanged)
{
if (lightSources.Count > 0)
{
DirectionalLight[] lights = { internalEffect.DirectionalLight0,
internalEffect.DirectionalLight1, internalEffect.DirectionalLight2 };
int numLightSource = lightSources.Count;
for (int i = 0; i < numLightSource; i++)
{
lights[i].Enabled = true;
lights[i].DiffuseColor = Vector3Helper.GetVector3(lightSources[i].Diffuse);
lights[i].Direction = lightSources[i].Direction;
lights[i].SpecularColor = Vector3Helper.GetVector3(lightSources[i].Specular);
}
}
}
alphaIndexer = (alphaIndexer + 1) % originalAlphas.Length;
}
else
{
Log.Write("Passed internal effect is not BasicEffect, so we can not apply the " +
"effect to this shader", Log.LogLevel.Warning);
}
}
else
{
skinnedEffect.Alpha = material.Diffuse.W;
skinnedEffect.DiffuseColor = Vector3Helper.GetVector3(material.Diffuse);
skinnedEffect.SpecularColor = Vector3Helper.GetVector3(material.Specular);
skinnedEffect.EmissiveColor = Vector3Helper.GetVector3(material.Emissive);
skinnedEffect.SpecularPower = material.SpecularPower;
skinnedEffect.Texture = material.Texture;
}
}
public void StopKeyframe(IPhysicsObject physObj)
{
if (!objectIDs.ContainsKey(physObj))
{
return;
}
Vector3 scale, trans;
Quaternion quat;
physObj.PhysicsWorldTransform.Decompose(out scale, out quat, out trans);
float[] pos = Vector3Helper.ToFloats(ref trans);
float[] rot = { quat.X, quat.Y, quat.Z, quat.W };
HavokDllBridge.apply_hard_keyframe(objectIDs[physObj], pos, rot, 0.016f);
}
