public void SwitchPartner(bool playerInLaser)
{
partnerPreviewRenderer.enabled = false;
previewRenderer.enabled = false;
partnerLinkedPair.timesFlipped += 1;
if (playerInLaser) //player is going to laser with this object, so partner should be set to real
{
ShaderUtility.ShaderToReal(partnerMaterial);
partner.GetComponent <Transition>().SetStart(1f);
StartCoroutine(flipTransitionRoutine(1, 0f, 1f, false));
partner.layer = 11;
}
else //player is going to real, so the pair should go to laser
{
ShaderUtility.ShaderToLaser(partnerMaterial);
partner.GetComponent <Transition>().SetStart(0f);
StartCoroutine(flipTransitionRoutine(0f, 1f, 1f, true));
partner.layer = 10;
}
}
protected override void OnLoad(EventArgs e)
{
// Set some GL state
GL.ClearColor(Color4.SkyBlue);
GL.Enable(EnableCap.DepthTest);
GL.Enable(EnableCap.CullFace);
mShader = new ShaderUtility(@"ACW/Shaders/vPassThrough.vert", @"ACW/Shaders/fLighting.frag");
GL.UseProgram(mShader.ShaderProgramID);
int vPositionLocation = GL.GetAttribLocation(mShader.ShaderProgramID, "vPosition");
int vNormalLocation = GL.GetAttribLocation(mShader.ShaderProgramID, "vNormal");
int vTexCoordsLocation = GL.GetAttribLocation(mShader.ShaderProgramID, "vTexCoords");
GL.GenVertexArrays(mVAO_IDs.Length, mVAO_IDs);
GL.GenBuffers(mVBO_IDs.Length, mVBO_IDs);
//ground
Textures.LoadTexture(mTexture_ID, 0, mShader);
Ground.GroundMethod(mVAO_IDs, mVBO_IDs, vPositionLocation, vNormalLocation, vTexCoordsLocation);
//armadillo
Textures.LoadTexture(mTexture_ID, 1, mShader);
mArmadilloModelUtility = ModelUtility.LoadModel(@"Utility/Models/model.bin");
Armadillo.ArmadilloMethod(mVAO_IDs, mVBO_IDs, mArmadilloModelUtility, vPositionLocation, vNormalLocation, vTexCoordsLocation);
//Cylinder Model
Textures.LoadTexture(mTexture_ID, 2, mShader);
mCylinderModelUtility = ModelUtility.LoadModel(@"Utility/Models/cylinder.bin");
Cylinder.CyclinderMethod(mVAO_IDs, mVBO_IDs, mCylinderModelUtility, vPositionLocation, vNormalLocation, vTexCoordsLocation);
//Sphere Model
Textures.LoadTexture(mTexture_ID, 3, mShader);
mSphereModelUtility = ModelUtility.LoadModel(@"Utility/Models/sphere.bin");
Sphere.SphereMethod(mVAO_IDs, mVBO_IDs, mSphereModelUtility, vPositionLocation, vNormalLocation, vTexCoordsLocation);
// End
mView = Matrix4.CreateTranslation(0.0f, -1.5f, 0.0f);
int uView = GL.GetUniformLocation(mShader.ShaderProgramID, "uView");
GL.UniformMatrix4(uView, true, ref mView);
mGroundModel = Matrix4.CreateTranslation(0.0f, 0.0f, -5.0f);
mArmadilloModel = Matrix4.CreateTranslation(0.0f, 3.0f, -5.0f); //sets armadillo position
Vector3 t = mArmadilloModel.ExtractTranslation();
Matrix4 translation = Matrix4.CreateTranslation(t);
Matrix4 inverseTranslation = Matrix4.CreateTranslation(-t);
mArmadilloModel = mArmadilloModel * inverseTranslation * Matrix4.CreateRotationY(-1.7f) * translation; // rotates armadillo
mCylinderModel = Matrix4.CreateTranslation(0.0f, 1.0f, -5.0f); //sets cylidner position
mSphereModel = Matrix4.CreateTranslation(5.0f, currentPosition, -3.0f); //sets Sphere position
base.OnLoad(e);
}
public void ShowPhysicsData(ref ShaderUtility mShader)
{
if (!World.gamePhysics.showPhysicsData)
{
return;
}
Vector4 normalVelocity = velocity.Normalized();
int uAmbientLightReflect = GL.GetUniformLocation(mShader.ShaderProgramID, "uMaterial.AmbientReflectivity");
GL.Uniform3(uAmbientLightReflect, this.material.Ambient);
Vector3 limeGreen = new Vector3(0, 100, 0);
Vector3 red = new Vector3(100, 0, 0);
Vector3 orange = new Vector3(100, 100, 0);
GL.Uniform3(uAmbientLightReflect, limeGreen);
//Likely Collision.
GL.Uniform3(uAmbientLightReflect, limeGreen);
GL.Begin(PrimitiveType.Lines);
GL.LineWidth(4);
GL.Vertex3(0, 0, 0);
GL.Vertex3(NearestContact.X, NearestContact.Y, NearestContact.Z);
GL.End();
//Velocity Vector
GL.LineWidth(2);
GL.Uniform3(uAmbientLightReflect, red);
GL.Begin(PrimitiveType.Lines);
GL.Vertex3(0, 0, 0);
GL.Vertex3(normalVelocity.X * 10, normalVelocity.Y * 10, normalVelocity.Z * 10);
GL.End();
GL.LineWidth(1);
}
public override void Drop()
{
Renderer r = GetComponent <Renderer>();
if (player.GetComponent <flipScript>().space)
{
//Going to real
ShaderUtility.ShaderWorldChange(r.material, false);
this.gameObject.layer = 11;
GetComponent <SelectionRenderChange>().OnDrop();
GetComponent <Transition>().SetStart(0f);
GetComponent <MorphController>().OnDeselection();
}
else
{
//Going to laser
ShaderUtility.ShaderWorldChange(r.material, true);
//GetComponent<Renderer>().material.shader = raycastManager.laserWorldShader;
this.gameObject.layer = 10;
GetComponent <SelectionRenderChange>().OnDrop();
GetComponent <Transition>().SetStart(1f);
GetComponent <MorphController>().OnDeselection();
}
_iconContainer.SetOpenHand();
selected = false;
rigidbody.freezeRotation = false;
rigidbody.GetComponent <Rigidbody>().constraints = RigidbodyConstraints.FreezeAll;
rigidbody.isKinematic = true;
ResetWalk();
}
public static void LoadSurface(ref ShaderUtility mShader)
{
VBO[0] = GL.GenBuffer();
//VBO[1] = GL.GenBuffer();
VAO = GL.GenVertexArray();
int vPositionLocation = GL.GetAttribLocation(mShader.ShaderProgramID, "vPosition");
int vNormal = GL.GetAttribLocation(mShader.ShaderProgramID, "vNormal");
//Ground verticies?
float[] vertices = new float[] { -1, 0, -1, 0, 1, 0,
-1, 0, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0,
1, 0, -1, 0, 1, 0, };
//Ground...
GL.BindVertexArray(VAO);
GL.BindBuffer(BufferTarget.ArrayBuffer, VBO[0]);
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertices.Length * sizeof(float)), vertices, BufferUsageHint.StaticDraw);
int size;
GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, out size);
if (vertices.Length * sizeof(float) != size)
{
throw new ApplicationException("Vertex data not loaded onto graphics card correctly");
}
GL.EnableVertexAttribArray(vPositionLocation);
GL.EnableVertexAttribArray(vNormal);
GL.VertexAttribPointer(vPositionLocation, 3, VertexAttribPointerType.Float, false, 6 * sizeof(float), 0);
GL.VertexAttribPointer(vNormal, 3, VertexAttribPointerType.Float, true, 6 * sizeof(float), 3 * sizeof(float));
}
public static void LoadCylinder(ref ShaderUtility mShader)
{
GL.GenBuffers(2, VBO);
VAO = GL.GenVertexArray();
int vPositionLocation = GL.GetAttribLocation(mShader.ShaderProgramID, "vPosition");
int vNormal = GL.GetAttribLocation(mShader.ShaderProgramID, "vNormal");
GL.BindVertexArray(VAO);
GL.BindBuffer(BufferTarget.ArrayBuffer, VBO[0]);
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(mModelUtility.Vertices.Length * sizeof(float)), mModelUtility.Vertices, BufferUsageHint.StaticDraw);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, VBO[1]);
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(mModelUtility.Indices.Length * sizeof(float)), mModelUtility.Indices, BufferUsageHint.StaticDraw);
int size;
GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, out size);
if (mModelUtility.Vertices.Length * sizeof(float) != size)
{
throw new ApplicationException("Vertex data not loaded onto graphics card correctly");
}
GL.GetBufferParameter(BufferTarget.ElementArrayBuffer, BufferParameterName.BufferSize, out size);
if (mModelUtility.Indices.Length * sizeof(float) != size)
{
throw new ApplicationException("Index data not loaded onto graphics card correctly");
}
GL.EnableVertexAttribArray(vPositionLocation);
GL.EnableVertexAttribArray(vNormal);
GL.VertexAttribPointer(vPositionLocation, 3, VertexAttribPointerType.Float, false, 6 * sizeof(float), 0);
GL.VertexAttribPointer(vNormal, 3, VertexAttribPointerType.Float, true, 6 * sizeof(float), 3 * sizeof(float));
}
//Render Static Objects.
public static void DrawStages(ref ShaderUtility mShader)
{
foreach (Shape obj in GlobalStaticObjects)
{
obj.Draw(ref mShader);
}
}
public void OnValidate(WaterCamera waterCamera)
{
ShaderUtility instance = ShaderUtility.Instance;
instance.Use(ShaderList.VolumesFrontSimple);
instance.Use(ShaderList.VolumesFront);
instance.Use(ShaderList.VolumesBack);
}
private void CreateMaterials()
{
ShaderUtility instance = ShaderUtility.Instance;
this._FinalMaterial = instance.CreateMaterial(ShaderList.RaindropsFinal, HideFlags.None);
this._FadeMaterial = instance.CreateMaterial(ShaderList.RaindropsFade, HideFlags.None);
this._DropletMaterial = instance.CreateMaterial(ShaderList.RaindropsParticle, HideFlags.None);
}
protected override void OnLoad(EventArgs e)
{
// Set some GL state
GL.ClearColor(Color4.DodgerBlue);
GL.Enable(EnableCap.DepthTest);
GL.Enable(EnableCap.CullFace);
mModel = ModelUtility.LoadModel(@"Utility/Models/lab22model.sjg");
mShader = new ShaderUtility(@"Lab2/Shaders/vLab22.vert", @"Lab2/Shaders/fSimple.frag");
GL.UseProgram(mShader.ShaderProgramID);
mView = Matrix4.CreateTranslation(0, 0, -2);
int uView = GL.GetUniformLocation(mShader.ShaderProgramID, "uView");
GL.UniformMatrix4(uView, true, ref mView);
int uProjectionLocation = GL.GetUniformLocation(mShader.ShaderProgramID, "uProjection");
Matrix4 projection = Matrix4.CreateOrthographic(10, 10, -1, 1);
GL.UniformMatrix4(uProjectionLocation, true, ref projection);
int vPositionLocation = GL.GetAttribLocation(mShader.ShaderProgramID, "vPosition");
int vColourLocation = GL.GetAttribLocation(mShader.ShaderProgramID, "vColour");
mVAO_ID = GL.GenVertexArray();
GL.GenBuffers(mVBO_IDs.Length, mVBO_IDs);
GL.BindVertexArray(mVAO_ID);
GL.BindBuffer(BufferTarget.ArrayBuffer, mVBO_IDs[0]);
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(mModel.Vertices.Length * sizeof(float)), mModel.Vertices, BufferUsageHint.StaticDraw);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, mVBO_IDs[1]);
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(mModel.Indices.Length * sizeof(float)), mModel.Indices, BufferUsageHint.StaticDraw);
int size;
GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, out size);
if (mModel.Vertices.Length * sizeof(float) != size)
{
throw new ApplicationException("Vertex data not loaded onto graphics card correctly");
}
GL.GetBufferParameter(BufferTarget.ElementArrayBuffer, BufferParameterName.BufferSize, out size);
if (mModel.Indices.Length * sizeof(float) != size)
{
throw new ApplicationException("Index data not loaded onto graphics card correctly");
}
GL.EnableVertexAttribArray(vPositionLocation);
GL.VertexAttribPointer(vPositionLocation, 3, VertexAttribPointerType.Float, false, 6 * sizeof(float), 0);
GL.EnableVertexAttribArray(vColourLocation);
GL.VertexAttribPointer(vColourLocation, 3, VertexAttribPointerType.Float, false, 6 * sizeof(float), 3 * sizeof(float));
GL.BindVertexArray(0);
base.OnLoad(e);
}
public override void Draw(ref ShaderUtility mShader)
{
int uModel = GL.GetUniformLocation(mShader.ShaderProgramID, "uModel");
GL.UniformMatrix4(uModel, true, ref mTransformations);
GL.BindVertexArray(VAO);
base.Draw(ref mShader);
GL.DrawElements(PrimitiveType.TriangleStrip, indices.Length, DrawElementsType.UnsignedInt, 0);
}
public override void Draw(ref ShaderUtility mShader)
{
int uModel = GL.GetUniformLocation(mShader.ShaderProgramID, "uModel");
GL.UniformMatrix4(uModel, true, ref mTransformations);
GL.BindVertexArray(VAO);
base.Draw(ref mShader);
GL.DrawArrays(PrimitiveType.TriangleFan, 0, 4);
}
private void _loadPath(Asset asset)
{
PathStyleBuilder builder = new PathStyleBuilder();
switch (asset.PathMaterialType)
{
case Asset.PathMaterial.Sheet:
{
Texture2D sheet = AssetPackUtilities.LoadAsset <Texture2D>(_bundle, asset.Guid + ".path_sheet");
Texture2D mask = AssetPackUtilities.LoadAsset <Texture2D>(_bundle, asset.Guid + ".path_mask");
Texture2D normal = AssetPackUtilities.LoadAsset <Texture2D>(_bundle, asset.Guid + ".path_normal");
CustomColorsMaskedNormalBuilder materialBuilder = ShaderUtility.PathMaterial();
if (sheet != null)
{
materialBuilder.MainTex(sheet);
}
materialBuilder.MainTex(sheet == null ? ShaderUtility.EmptyTexture : sheet);
materialBuilder.MaskTex(mask == null ? ShaderUtility.EmptyTexture : mask);
materialBuilder.NormalTex(normal == null ? ShaderUtility.EmptyTexture : normal);
builder.Material(materialBuilder.build())
.Id(asset.Guid)
.Name(asset.Name)
.CustomColor(AssetPackUtilities.ConvertColors(asset.CustomColors, asset.ColorCount))
.Register(asset.PathType, _assetManagerLoader,
PathStyleBuilder.GetPathStyle(PathStyleBuilder.NormalPathIds.Gravel,
PathStyleBuilder.PathType.Normal));
}
break;
case Asset.PathMaterial.Tiled:
{
Texture2D sheet = AssetPackUtilities.LoadAsset <Texture2D>(_bundle, asset.Guid + ".path_sheet");
Texture2D mask = AssetPackUtilities.LoadAsset <Texture2D>(_bundle, asset.Guid + ".path_mask");
Texture2D normal = AssetPackUtilities.LoadAsset <Texture2D>(_bundle, asset.Guid + ".path_normal");
CustomColorMaskedCutoutBuilder materialBuilder = ShaderUtility.PathMaterialTiled();
if (sheet != null)
{
materialBuilder.MainTex(sheet);
}
materialBuilder.MaskTex(mask == null ? ShaderUtility.EmptyTexture : mask);
materialBuilder.MainTex(sheet == null ? ShaderUtility.EmptyTexture : sheet);
materialBuilder.NormalTex(normal == null ? ShaderUtility.EmptyTexture : normal);
builder.Material(materialBuilder.build())
.Id(asset.Guid)
.CustomColor(AssetPackUtilities.ConvertColors(asset.CustomColors, asset.ColorCount))
.Name(asset.Name)
.Register(asset.PathType, _assetManagerLoader,
PathStyleBuilder.GetPathStyle(PathStyleBuilder.NormalPathIds.Concrete,
PathStyleBuilder.PathType.Normal));
}
break;
}
}
protected override void OnLoad(EventArgs e)
{
GL.ClearColor(Color4.CadetBlue);
float[] vertices = new float[] { -0.8f, 0.8f,
-0.6f, -0.4f,
0.2f, 0.2f };
uint[] indices = new uint[] { 0, 1, 2 };
GL.GenBuffers(2, mTriangleVertexBufferObjectIDArray);
GL.BindBuffer(BufferTarget.ArrayBuffer, mTriangleVertexBufferObjectIDArray[0]);
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertices.Length * sizeof(float)), vertices, BufferUsageHint.StaticDraw);
vertices = new float[] { -0.2f, -0.4f,
0.8f, -0.4f,
0.8f, 0.6f,
-0.2f, 0.6f };
indices = new uint[] { 0, 1, 2, 3 };
GL.GenBuffers(2, mSquareVertexBufferObjectIDArray);
GL.BindBuffer(BufferTarget.ArrayBuffer, mSquareVertexBufferObjectIDArray[0]);
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertices.Length * sizeof(float)), vertices, BufferUsageHint.StaticDraw);
int size;
GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, out size);
if (vertices.Length * sizeof(float) != size)
{
throw new ApplicationException("Vertex data not loaded onto graphics card correctly");
}
GL.BindBuffer(BufferTarget.ElementArrayBuffer, mTriangleVertexBufferObjectIDArray[1]);
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(indices.Length * sizeof(int)), indices, BufferUsageHint.StaticDraw);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, mSquareVertexBufferObjectIDArray[1]);
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(indices.Length * sizeof(int)), indices, BufferUsageHint.StaticDraw);
GL.GetBufferParameter(BufferTarget.ElementArrayBuffer, BufferParameterName.BufferSize, out size);
if (indices.Length * sizeof(int) != size)
{
throw new ApplicationException("Index data not loaded onto graphics card correctly");
}
#region Shader Loading Code
mShader = new ShaderUtility(@"Lab2/Shaders/vLab21.vert", @"Lab2/Shaders/fSimple.frag");
#endregion
base.OnLoad(e);
}
private void Start()
{
_material = GetComponent <MeshRenderer>().material;
_collision = new RayCastMeshCollisionUseCase(CachedTransform);
_collision.HitDirection.Pairwise().Subscribe(dir =>
{
_material.DisableKeyword(ShaderUtility.GetKeywordForMeshDirection(dir.Previous));
_material.EnableKeyword(ShaderUtility.GetKeywordForMeshDirection(dir.Current));
}).AddTo(gameObject);
}
} //used in flippable
public virtual void LoadShader(bool real)
{
if (real)
{
ShaderUtility.ShaderToReal(_material);
}
else
{
ShaderUtility.ShaderToLaser(_material);
}
}
//Adds a bit of colour...
public virtual void Draw(ref ShaderUtility mShader)
{
int uAmbientLightReflect = GL.GetUniformLocation(mShader.ShaderProgramID, "uMaterial.AmbientReflectivity");
int uDiffuseLightReflect = GL.GetUniformLocation(mShader.ShaderProgramID, "uMaterial.DiffuseReflectivity");
int uSpecularLightReflect = GL.GetUniformLocation(mShader.ShaderProgramID, "uMaterial.SpecularReflectivity");
int uShine = GL.GetUniformLocation(mShader.ShaderProgramID, "uMaterial.Shininess");
GL.Uniform3(uAmbientLightReflect, this.material.Ambient);
GL.Uniform3(uDiffuseLightReflect, this.material.Diffuse);
GL.Uniform3(uSpecularLightReflect, this.material.Specular);
GL.Uniform1(uShine, this.material.Shininess);
}
public override void Draw(ref ShaderUtility mShader)
{
int uModel = GL.GetUniformLocation(mShader.ShaderProgramID, "uModel");
mTransformations.M41 = vPosition.X;
mTransformations.M42 = vPosition.Y;
mTransformations.M43 = vPosition.Z;
GL.UniformMatrix4(uModel, true, ref mTransformations);
GL.BindVertexArray(VAO);
base.Draw(ref mShader);
GL.DrawElements(PrimitiveType.Triangles, mModelUtility.Indices.Length, DrawElementsType.UnsignedInt, 0);
DistanceToNearestObject = 1000;
}
protected override void OnLoad(EventArgs e)
{
mTimer = new Timer();
mTimer.Start();
// Set some GL state
GL.ClearColor(Color4.White);
GL.Enable(EnableCap.CullFace);
#region mostly shader stuff, +camera matrix
//Shader Initialisation/Lighting
mShader = new ShaderUtility(@"ACW/Shaders/vLighting.vert", @"ACW/Shaders/fLighting.frag");
GL.UseProgram(mShader.ShaderProgramID);
mView = Matrix4.CreateTranslation(0, 3.5f, -10);
Vector3[] colour = { new Vector3(2f, 0f, 0f), new Vector3(0f, 1.5f, 0f), new Vector3(1f, 1.4f, 1.5f) };
for (int i = 0; i < 3; i++)
{
uLightPositionLocation[i] = GL.GetUniformLocation(mShader.ShaderProgramID, "uLight[" + i + "].Position");
//Vector3 colour = new Vector3(0.1f, 0.0f, 0.0f);
lightPosition[i] = lightOrigins[i];// new Vector4(2+ i, 4 - i, -8.5f, 1);
lightPosition[i] = Vector4.Transform(lightPosition[i], mView);
GL.Uniform4(uLightPositionLocation[i], lightPosition[i]);
uAmbientLightLocation = GL.GetUniformLocation(mShader.ShaderProgramID, "uLight[" + i + "].AmbientLight");
GL.Uniform3(uAmbientLightLocation, colour[i] / 10);
uDiffuseLightLocation = GL.GetUniformLocation(mShader.ShaderProgramID, "uLight[" + i + "].DiffuseLight");
GL.Uniform3(uDiffuseLightLocation, colour[i]);
uSpecularLightLocation = GL.GetUniformLocation(mShader.ShaderProgramID, "uLight[" + i + "].SpecularLight");
GL.Uniform3(uSpecularLightLocation, colour[i]);
}
int vPositionLocation = GL.GetAttribLocation(mShader.ShaderProgramID, "vPosition");
int vNormal = GL.GetAttribLocation(mShader.ShaderProgramID, "vNormal");
uEyePos = GL.GetUniformLocation(mShader.ShaderProgramID, "uEyePosition");
GL.Uniform4(uEyePos, mView.Row3);
#endregion
Surface.LoadSurface(ref mShader);
Ball.LoadGeometry(ref mShader);
Cylinder.LoadCylinder(ref mShader);
Box.LoadSurface(ref mShader);
GL.BindVertexArray(0);
int uView = GL.GetUniformLocation(mShader.ShaderProgramID, "uView");
GL.UniformMatrix4(uView, true, ref mView);
World.InitRegions();
cam = new Camera(mView);
base.OnLoad(e);
}
private void Start()
{
if (currentFlips < flipCountActivate)
{
GetComponent <Transition>().enabled = false;
GetComponent <Renderer>().enabled = false;
}
player = Toolbox.Instance.GetPlayer();
Material material = GetComponent <Renderer>().material;
visibleInlaser = ShaderUtility.ShaderIsLaser(material);
}
public override void Drop()
{
StopAllCoroutines();
wait = false;
currentPositionVelocity = originalVelocity;
//put the object down with the right shader
if (player.GetComponent <flipScript>().space)
{
ShaderUtility.ShaderToReal(_renderer.material);
GetComponent <Transition>().SetStart(0f);
SetMaterialFloatProp("_onHover", 1);
//renderer.material.SetInt("_onHold", 0);
this.gameObject.layer = 11;
}
else
{
ShaderUtility.ShaderToLaser(_renderer.material);
GetComponent <Transition>().SetStart(1f);
OffSelect();
SetMaterialFloatProp("_onHover", 1);
//renderer.material.SetInt("_onHold", 0);
this.gameObject.layer = 10;
}
Vector3 currentVelocity = rigidbody.velocity;
if (currentVelocity.magnitude > maxVelocity)
{
//.Log("before " + currentVelocity);
rigidbody.velocity = Vector3.ClampMagnitude(currentVelocity, maxVelocity);
//Debug.Log(rigidbody.velocity + ", " + rigidbody.velocity.magnitude);
}
FlipCore(false);
_iconContainer.SetOpenHand();
selected = false;
OffSelect();
rigidbody.freezeRotation = false;
beenPickedUp = true;
rigidbody.constraints = RigidbodyConstraints.None;
rigidbody.useGravity = true;
ResetWalk();
}
protected override void OnLoad(EventArgs e)
{
GL.ClearColor(Color4.ForestGreen);
float[] vertices = new float[] { 0.0f, 0.8f,
0.8f, 0.4f,
0.6f, -0.6f,
-0.6f, -0.6f,
-0.8f, 0.4f };
uint[] indices = new uint[] { 0, 4, 1,
3,
2 };
GL.GenBuffers(2, mVertexBufferObjectIDArray);
GL.BindBuffer(BufferTarget.ArrayBuffer, mVertexBufferObjectIDArray[0]);
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertices.Length * sizeof(float)), vertices, BufferUsageHint.StaticDraw);
int size;
GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, out size);
if (vertices.Length * sizeof(float) != size)
{
throw new ApplicationException("Vertex data not loaded onto graphics card correctly");
}
GL.BindBuffer(BufferTarget.ElementArrayBuffer, mVertexBufferObjectIDArray[1]);
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(indices.Length * sizeof(uint)), indices, BufferUsageHint.StaticDraw);
GL.GetBufferParameter(BufferTarget.ElementArrayBuffer, BufferParameterName.BufferSize, out size);
if (indices.Length * sizeof(uint) != size)
{
throw new ApplicationException("Index data not loaded onto graphics card correctly");
}
#region Shader Loading Code - Can be ignored for now
mShader = new ShaderUtility(@"Lab1/Shaders/vSimple.vert", @"Lab1/Shaders/fSimple.frag");
#endregion
GL.Enable(EnableCap.CullFace);
base.OnLoad(e);
}
public void Flip(bool dir)
{
//quick setup for if we're changing the core shader before the core itself has done the awake
if (!renderMat)
{
renderMat = GetComponent <Renderer>().material;
}
if (dir)
{
ShaderUtility.ShaderToLaser(renderMat);
GetComponent <Transition>().SetStart(1f);
}
else
{
ShaderUtility.ShaderToReal(renderMat);
GetComponent <Transition>().SetStart(0f);
}
}
public bool GetTransitioning()
{
if (!mRenderer)
{
return(false);
}
mRenderer.GetPropertyBlock(_propBlock);
float currentTransitionState = _propBlock.GetFloat("_TransitionState");
if (Toolbox.Instance.PlayerInReal() && ShaderUtility.ShaderIsReal(material) && (currentTransitionState < .001f) ||
Toolbox.Instance.PlayerInLaser() && ShaderUtility.ShaderIsLaser(material) && (currentTransitionState > .999f) ||
(!ShaderUtility.ShaderIsReal(material) && !ShaderUtility.ShaderIsLaser(material)))
{
return(false);
}
return(true);
}
private void RefreshShaderKeywords()
{
m_GlobalKeywords.Clear();
for (int iKeyword = 0; iKeyword < UnityEngineReflectionUtility.ShaderKeyword.MAX_SHADER_KEYWORDS; iKeyword++)
{
ShaderKeyword iterKeyword = UnityEngineReflectionUtility.ShaderKeyword.NewShaderKeyword(iKeyword);
string keywordName = ShaderKeyword.GetGlobalKeywordName(iterKeyword);
if (!ShaderUtility.IsValidAndUsed(iterKeyword, keywordName))
{
continue;
}
KeywordItem keywordItem = new KeywordItem();
keywordItem.KeywordName = keywordName;
keywordItem.KeywordType = ShaderKeyword.GetGlobalKeywordType(iterKeyword);
keywordItem.Enable = Shader.IsKeywordEnabled(keywordItem.KeywordName);
keywordItem.Content = new GUIContent(keywordItem.KeywordName);
m_GlobalKeywords.Add(keywordItem);
}
}
public void FlipInternalRenderers(renderersAndProps[] internals, bool dir)
{
float currentTransitionState = internals[0].renderer.material.GetFloat("_TransitionState");
foreach (renderersAndProps r in internals)
{
ShaderUtility.ShaderWorldChange(r.renderer.material, dir);
r.renderer.GetPropertyBlock(r.propertyBlock);
if (dir)
{
r.propertyBlock.SetFloat("_TransitionState", 1f - currentTransitionState);
}
else
{
r.propertyBlock.SetFloat("_TransitionState", currentTransitionState);
}
r.renderer.SetPropertyBlock(r.propertyBlock);
}
}
public void SimulateFrame(float timestep, ShaderUtility mShader)
{
foreach (Ball b in SpatialRegion.OverheadController_AllBalls)
{
b.vOldPosition = b.vPosition;
PositionUpdate(b, timestep);
CheckFor_SpherePlane_Collision(b);
}
SpatialRegion.SpatialPartitioningController();
foreach (SpatialRegion space in SpatialRegion.AllRegions)
{
space.DoCollisionChecks(); //Each Spatial Segment Handles it's own collision detection calls.
}
//Remove dead objects from simlation. Go on Garbage Collector, do your thing.
while (cleanupList.Count > 0)
{
cleanupList[0].KillRegions();
SpatialRegion.OverheadController_AllBalls.Remove(cleanupList[0]);
cleanupList.Remove(cleanupList[0]);
}
}
protected override void OnLoad(EventArgs e)
{
// Set some GL state
GL.ClearColor(Color4.Firebrick);
mTimer.Start();
string filepath = @"Lab5/texture.jpg";
Bitmap TextureBitmap;
BitmapData TextureData;
if (System.IO.File.Exists(filepath))
{
TextureBitmap = new Bitmap(filepath);
TextureBitmap.RotateFlip(RotateFlipType.RotateNoneFlipY);
TextureData = TextureBitmap.LockBits(new System.Drawing.Rectangle(0, 0, TextureBitmap.Width, TextureBitmap.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppRgb);
}
else
{
throw new Exception("Could not find file " + filepath);
}
int mTexture_ID;
GL.ActiveTexture(TextureUnit.Texture0);
GL.GenTextures(1, out mTexture_ID);
GL.BindTexture(TextureTarget.Texture2D, mTexture_ID);
GL.TexImage2D(TextureTarget.Texture2D,
0, PixelInternalFormat.Rgba, TextureData.Width, TextureData.Height,
0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra,
PixelType.UnsignedByte, TextureData.Scan0);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
TextureBitmap.UnlockBits(TextureData);
Bitmap TextureBitmap2;
BitmapData TextureData2;
filepath = @"Lab5/textureDisolveMap.jpg";
if (System.IO.File.Exists(filepath))
{
TextureBitmap2 = new Bitmap(filepath);
TextureBitmap2.RotateFlip(RotateFlipType.RotateNoneFlipY);
TextureData2 = TextureBitmap2.LockBits(new System.Drawing.Rectangle(0, 0, TextureBitmap2.Width, TextureBitmap2.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppRgb);
}
else
{
throw new Exception("Could not find file " + filepath);
}
int mTexture_ID2;
GL.ActiveTexture(TextureUnit.Texture1);
GL.GenTextures(1, out mTexture_ID2);
GL.BindTexture(TextureTarget.Texture2D, mTexture_ID2);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, TextureData2.Width, TextureData2.Height, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, TextureData2.Scan0);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
TextureBitmap2.UnlockBits(TextureData2);
float[] vertices = { -0.5f, -0.5f, 0.0f, 0.0f,
-0.25f, -0.5f, 0.25f, 0f,
0.0f, -0.5f, 0.5f, 0.0f,
0.25f, -0.5f, 0.75f, 0f,
0.5f, -0.5f, 1f, 0f,
-0.5f, 0.0f, 0.0f, 0.5f,
-0.25f, 0.0f, 0.25f, 0.5f,
0.0f, 0.0f, 0.5f, 0.5f,
0.25f, 0.0f, 0.75f, 0.5f,
0.5f, 0.0f, 1f, 0.5f,
-0.5f, 0.5f, 0f, 1f,
-0.25f, 0.5f, 0.25f, 1f,
0.0f, 0.5f, 0.5f, 1f,
0.25f, 0.5f, 0.75f, 1f,
0.5f, 0.5f, 1f, 1f };
uint[] indices = { 5, 0, 1,
5, 1, 6,
6, 1, 2,
6, 2, 7,
7, 2, 3,
7, 3, 8,
8, 3, 4,
8, 4, 9,
10, 5, 6,
10, 6, 11,
11, 6, 7,
11, 7, 12,
12, 7, 8,
12, 8, 13,
13, 8, 9,
13, 9, 14 };
GL.Enable(EnableCap.CullFace);
mShader = new ShaderUtility(@"Lab5/Shaders/vTexture.vert", @"Lab5/Shaders/fTexture.frag");
GL.UseProgram(mShader.ShaderProgramID);
int vPositionLocation = GL.GetAttribLocation(mShader.ShaderProgramID, "vPosition");
int vTextCoordsLocation = GL.GetAttribLocation(mShader.ShaderProgramID, "vTexCoords");
int uTextureSamplerLocation = GL.GetUniformLocation(mShader.ShaderProgramID, "uTextureSampler");
int uTextureSamplerLocation2 = GL.GetUniformLocation(mShader.ShaderProgramID, "uTextureSampler2");
int uThresholdLocation = GL.GetUniformLocation(mShader.ShaderProgramID, "uThreshold");
GL.Uniform1(uTextureSamplerLocation, 0);
GL.Uniform1(uTextureSamplerLocation2, 1);
GL.Uniform1(uThresholdLocation, 0.5f);
mVAO_ID = GL.GenVertexArray();
GL.GenBuffers(mVBO_IDs.Length, mVBO_IDs);
GL.BindVertexArray(mVAO_ID);
GL.BindBuffer(BufferTarget.ArrayBuffer, mVBO_IDs[0]);
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertices.Length * sizeof(float)), vertices, BufferUsageHint.StaticDraw);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, mVBO_IDs[1]);
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(indices.Length * sizeof(uint)), indices, BufferUsageHint.StaticDraw);
int size;
GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, out size);
if (vertices.Length * sizeof(float) != size)
{
throw new ApplicationException("Vertex data not loaded onto graphics card correctly");
}
GL.GetBufferParameter(BufferTarget.ElementArrayBuffer, BufferParameterName.BufferSize, out size);
if (indices.Length * sizeof(uint) != size)
{
throw new ApplicationException("Index data not loaded onto graphics card correctly");
}
GL.EnableVertexAttribArray(vPositionLocation);
GL.EnableVertexAttribArray(vTextCoordsLocation);
GL.VertexAttribPointer(vPositionLocation, 2, VertexAttribPointerType.Float, false, 4 * sizeof(float), 0);
GL.VertexAttribPointer(vTextCoordsLocation, 2, VertexAttribPointerType.Float, false, 4 * sizeof(float), 2 * sizeof(float));
GL.BindVertexArray(0);
base.OnLoad(e);
}
protected override void OnLoad(EventArgs e)
{
GL.ClearColor(Color4.CadetBlue);
GL.Enable(EnableCap.DepthTest);
//L21T5 Added depth by adding an extra vertex parameter, changing the shader variable and linking and enabling depth testing
//Triangle data
float[] tVertices = new float[] { -0.8f, 0.8f, 0.4f, 0.8f, 0.2f, 1.0f,
-0.6f, -0.4f, 0.4f, 0.2f, 1.0f, 0.8f,
0.2f, 0.2f, 0.4f, 1.0f, 0.8f, 0.2f };
uint[] tIndices = new uint[] { 0, 1, 2 };
//Square data
float[] sVertices = new float[] { -0.2f, -0.4f, 0.2f, 1.0f, 0.5f, 0.9f,
0.8f, -0.4f, 0.2f, 0.5f, 1.0f, 0.9f,
-0.2f, 0.6f, 0.2f, 0.5f, 0.9f, 1.0f,
0.8f, 0.6f, 0.2f, 0.0f, 0.0f, 0.0f };
uint[] sIndices = new uint[] { 0, 1, 3, 2 };
//L21T7 Changed vertex colours to see fragments colour values being blended together
//Triangle buffers
GL.GenBuffers(2, mVertexBufferObjectIDArray);
GL.BindBuffer(BufferTarget.ArrayBuffer, mVertexBufferObjectIDArray[0]);
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(tVertices.Length * sizeof(float)), tVertices, BufferUsageHint.StaticDraw);
int size;
GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, out size);
if (tVertices.Length * sizeof(float) != size)
{
throw new ApplicationException("Vertex data not loaded onto graphics card correctly");
}
GL.BindBuffer(BufferTarget.ElementArrayBuffer, mVertexBufferObjectIDArray[1]);
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(tIndices.Length * sizeof(int)), tIndices, BufferUsageHint.StaticDraw);
GL.GetBufferParameter(BufferTarget.ElementArrayBuffer, BufferParameterName.BufferSize, out size);
if (tIndices.Length * sizeof(int) != size)
{
throw new ApplicationException("Index data not loaded onto graphics card correctly");
}
//Square Buffers
GL.GenBuffers(2, mSquareBufferObjectIDArray);
GL.BindBuffer(BufferTarget.ArrayBuffer, mSquareBufferObjectIDArray[0]);
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(sVertices.Length * sizeof(float)), sVertices, BufferUsageHint.StaticDraw);
GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, out size);
if (sVertices.Length * sizeof(float) != size)
{
throw new ApplicationException("Vertex data not loaded onto graphics card correctly");
}
GL.BindBuffer(BufferTarget.ElementArrayBuffer, mSquareBufferObjectIDArray[1]);
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(sIndices.Length * sizeof(int)), sIndices, BufferUsageHint.StaticDraw);
GL.GetBufferParameter(BufferTarget.ElementArrayBuffer, BufferParameterName.BufferSize, out size);
if (sIndices.Length * sizeof(int) != size)
{
throw new ApplicationException("Index data not loaded onto graphics card correctly");
}
#region Shader Loading Code
mShader = new ShaderUtility(@"Lab2/Shaders/vLab21.vert", @"Lab2/Shaders/fSimple.frag");
#endregion
int vColourLocation = GL.GetAttribLocation(mShader.ShaderProgramID, "vColour");
GL.EnableVertexAttribArray(vColourLocation);
int vPositionLocation = GL.GetAttribLocation(mShader.ShaderProgramID, "vPosition");
GL.EnableVertexAttribArray(vPositionLocation);
//Square buffer binding
GL.GenVertexArrays(2, mVertexArrayObjectIDs);
GL.BindVertexArray(mVertexArrayObjectIDs[1]);
GL.BindBuffer(BufferTarget.ArrayBuffer, mSquareBufferObjectIDArray[0]);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, mSquareBufferObjectIDArray[1]);
GL.VertexAttribPointer(vPositionLocation, 3, VertexAttribPointerType.Float, false, 6 *
sizeof(float), 0);
GL.VertexAttribPointer(vColourLocation, 3, VertexAttribPointerType.Float, false, 6 *
sizeof(float), 3 * sizeof(float));
GL.EnableVertexAttribArray(vColourLocation);
GL.EnableVertexAttribArray(vPositionLocation);
//Triangle buffer binding
GL.BindVertexArray(mVertexArrayObjectIDs[0]);
GL.BindBuffer(BufferTarget.ArrayBuffer, mVertexBufferObjectIDArray[0]);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, mVertexBufferObjectIDArray[1]);
GL.VertexAttribPointer(vPositionLocation, 3, VertexAttribPointerType.Float, false, 6 *
sizeof(float), 0);
GL.VertexAttribPointer(vColourLocation, 3, VertexAttribPointerType.Float, false, 6 *
sizeof(float), 3 * sizeof(float));
GL.EnableVertexAttribArray(vColourLocation);
GL.EnableVertexAttribArray(vPositionLocation);
base.OnLoad(e);
}
protected override void OnLoad(EventArgs e)
{
GL.ClearColor(Color4.Black);
//Drawing triforce.
/*
* float[] vertices = new float[] { -0.4f, 0.0f,
* 0.4f, 0.0f,
* 0.0f, 0.6f,
* -0.8f, -0.6f,
* 0.0f, -0.6f,
* 0.8f, -0.6f };
*
* uint[] indices = new uint[] {0,1,2,0,3,4,1,4,5};
*/
//Drawing house.
/*
* float[] vertices = new float[] { -0.4f, -0.2f,
* -0.4f, -0.6f,
* 0.2f, -0.2f,
* 0.2f, -0.6f,
* -0.6f, 0.2f,
* -0.6f, -0.6f,
* -0.4f, 0.2f,
* -0.4f, 0.6f,
* 0.4f, 0.6f,
* 0.4f, 0.2f,
* 0.0f, 0.2f,
* 0.0f, -0.2f,
* 0.4f, -0.2f,
* 0.4f, -0.6f,
* 0.6f, 0.2f,
* 0.6f, -0.6f,
* 0.8f, 0.2f,
* -0.8f, 0.2f,
* -0.2f, 0.8f,
* -0.2f, 0.6f,
* 0.0f, 0.8f,
* 0.0f, 0.6f };
*
* uint[] indices = new uint[] { 0, 1, 2, 2, 1, 3, 4, 5, 6, 6, 5, 1, 7, 6, 8, 8, 6, 9, 7, 17, 6, 8, 9, 16, 18, 19, 20, 20, 19, 21, 10, 11, 9, 9, 11, 12, 9, 13, 14, 14, 13, 15 };
*/
float[] vertices = new float[] { 0.0f, 0.8f,
0.8f, 0.4f,
0.6f, -0.6f,
-0.6f, -0.6f,
-0.8f, 0.4f };
uint[] indices = new uint[] { 4, 3, 0, 2, 1 };
GL.GenBuffers(2, mVertexBufferObjectIDArray);
GL.BindBuffer(BufferTarget.ArrayBuffer, mVertexBufferObjectIDArray[0]);
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertices.Length * sizeof(float)), vertices, BufferUsageHint.StaticDraw);
GL.Enable(EnableCap.CullFace);
int size;
GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, out size);
if (vertices.Length * sizeof(float) != size)
{
throw new ApplicationException("Vertex data not loaded onto graphics card correctly");
}
GL.BindBuffer(BufferTarget.ElementArrayBuffer, mVertexBufferObjectIDArray[1]);
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(indices.Length * sizeof(uint)),
indices, BufferUsageHint.StaticDraw);
GL.GetBufferParameter(BufferTarget.ElementArrayBuffer, BufferParameterName.BufferSize, out
size);
if (indices.Length * sizeof(uint) != size)
{
throw new ApplicationException("Index data not loaded onto graphics card correctly");
}
#region Shader Loading Code - Can be ignored for now
mShader = new ShaderUtility(@"Lab1/Shaders/vSimple.vert", @"Lab1/Shaders/fSimple.frag");
#endregion
base.OnLoad(e);
}
public void OnEnable()
{
m_instance = (target as ShaderUtility);
m_shaderListProperty = serializedObject.FindProperty("m_shaderList");
}
