//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
public static Matrix4X4 MakeFrustrum(float left, float right, float bottom, float top, float znear, float zfar)
{
Matrix4X4 ret = new Matrix4X4(null);
float rl = (right - left);
float tb = (top - bottom);
float fn = (zfar - znear);
ret.Elements[0] = (znear * 2) / rl;
ret.Elements[1] = 0;
ret.Elements[2] = 0;
ret.Elements[3] = 0;
ret.Elements[4] = 0;
ret.Elements[5] = (znear * 2) / tb;
ret.Elements[6] = 0;
ret.Elements[7] = 0;
ret.Elements[8] = (right + left) / rl;
ret.Elements[9] = (top + bottom) / tb;
ret.Elements[10] = -(zfar + znear) / fn;
ret.Elements[11] = -1;
ret.Elements[12] = 0;
ret.Elements[13] = 0;
ret.Elements[14] = -(zfar * znear * 2) / fn;
ret.Elements[15] = 0;
return ret;
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
public static Matrix4X4 MakeLookAt(Vector3 eye, Vector3 center, Vector3 up)
{
Matrix4X4 ret = new Matrix4X4(null);
float eyex = eye.Elements[0],
eyey = eye.Elements[1],
eyez = eye.Elements[2],
upx = up.Elements[0],
upy = up.Elements[1],
upz = up.Elements[2],
centerx = center.Elements[0],
centery = center.Elements[1],
centerz = center.Elements[2];
float z0, z1, z2, x0, x1, x2, y0, y1, y2, len;
//vec3.direction(eye, center, z);
z0 = eyex - center.Elements[0];
z1 = eyey - center.Elements[1];
z2 = eyez - center.Elements[2];
// normalize (no check needed for 0 because of early return)
len = 1 / Math.Sqrt(z0 * z0 + z1 * z1 + z2 * z2);
z0 *= len;
z1 *= len;
z2 *= len;
//vec3.normalize(vec3.cross(up, z, x));
x0 = upy * z2 - upz * z1;
x1 = upz * z0 - upx * z2;
x2 = upx * z1 - upy * z0;
len = Math.Sqrt(x0 * x0 + x1 * x1 + x2 * x2);
if (len == 0) {
x0 = 0;
x1 = 0;
x2 = 0;
} else {
len = 1 / len;
x0 *= len;
x1 *= len;
x2 *= len;
};
//vec3.normalize(vec3.cross(z, x, y));
y0 = z1 * x2 - z2 * x1;
y1 = z2 * x0 - z0 * x2;
y2 = z0 * x1 - z1 * x0;
len = Math.Sqrt(y0 * y0 + y1 * y1 + y2 * y2);
if (len == 0) {
y0 = 0;
y1 = 0;
y2 = 0;
} else {
len = 1 / len;
y0 *= len;
y1 *= len;
y2 *= len;
}
ret.Elements[0] = x0;
ret.Elements[1] = y0;
ret.Elements[2] = z0;
ret.Elements[3] = 0;
ret.Elements[4] = x1;
ret.Elements[5] = y1;
ret.Elements[6] = z1;
ret.Elements[7] = 0;
ret.Elements[8] = x2;
ret.Elements[9] = y2;
ret.Elements[10] = z2;
ret.Elements[11] = 0;
ret.Elements[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
ret.Elements[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
ret.Elements[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
ret.Elements[15] = 1;
return ret;
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
public Matrix4X4 MultiplyMInv(Matrix4X4 other)
{
float a00 = Elements[0], a01 = Elements[1], a02 = Elements[2], a03 = Elements[3];
float a10 = Elements[4], a11 = Elements[5], a12 = Elements[6], a13 = Elements[7];
float a20 = Elements[8], a21 = Elements[9], a22 = Elements[10], a23 = Elements[11];
float a30 = Elements[12], a31 = Elements[13], a32 = Elements[14], a33 = Elements[15];
float b00 = other.Elements[0], b01 = other.Elements[1], b02 = other.Elements[2], b03 = other.Elements[3];
float b10 = other.Elements[4], b11 = other.Elements[5], b12 = other.Elements[6], b13 = other.Elements[7];
float b20 = other.Elements[8], b21 = other.Elements[9], b22 = other.Elements[10], b23 = other.Elements[11];
float b30 = other.Elements[12], b31 = other.Elements[13], b32 = other.Elements[14], b33 = other.Elements[15];
Elements[0] = a00 * b00 + a01 * b10 + a02 * b20 + a03 * b30;
Elements[1] = a00 * b01 + a01 * b11 + a02 * b21 + a03 * b31;
Elements[2] = a00 * b02 + a01 * b12 + a02 * b22 + a03 * b32;
Elements[3] = a00 * b03 + a01 * b13 + a02 * b23 + a03 * b33;
Elements[4] = a10 * b00 + a11 * b10 + a12 * b20 + a13 * b30;
Elements[5] = a10 * b01 + a11 * b11 + a12 * b21 + a13 * b31;
Elements[6] = a10 * b02 + a11 * b12 + a12 * b22 + a13 * b32;
Elements[7] = a10 * b03 + a11 * b13 + a12 * b23 + a13 * b33;
Elements[8] = a20 * b00 + a21 * b10 + a22 * b20 + a23 * b30;
Elements[9] = a20 * b01 + a21 * b11 + a22 * b21 + a23 * b31;
Elements[10] = a20 * b02 + a21 * b12 + a22 * b22 + a23 * b32;
Elements[11] = a20 * b03 + a21 * b13 + a22 * b23 + a23 * b33;
Elements[12] = a30 * b00 + a31 * b10 + a32 * b20 + a33 * b30;
Elements[13] = a30 * b01 + a31 * b11 + a32 * b21 + a33 * b31;
Elements[14] = a30 * b02 + a31 * b12 + a32 * b22 + a33 * b32;
Elements[15] = a30 * b03 + a31 * b13 + a32 * b23 + a33 * b33;
return this;
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
public Matrix4X4 MultiplyAffineM(Matrix4X4 other)
{
float[] newe = SystemCore.Environment.CreateFloat32Array(16);
newe[0] = this.Elements[0] * other.Elements[0] + this.Elements[4] * other.Elements[1] +
this.Elements[8] * other.Elements[2];
newe[1] = this.Elements[1] * other.Elements[0] + this.Elements[5] * other.Elements[1] +
this.Elements[9] * other.Elements[2];
newe[2] = this.Elements[2] * other.Elements[0] + this.Elements[6] * other.Elements[1] +
this.Elements[10] * other.Elements[2];
newe[3] = 0;
newe[4] = this.Elements[0] * other.Elements[4] + this.Elements[4] * other.Elements[5] +
this.Elements[8] * other.Elements[6];
newe[5] = this.Elements[1] * other.Elements[4] + this.Elements[5] * other.Elements[5] +
this.Elements[9] * other.Elements[6];
newe[6] = this.Elements[2] * other.Elements[4] + this.Elements[6] * other.Elements[5] +
this.Elements[10] * other.Elements[6];
newe[7] = 0;
newe[8] = this.Elements[0] * other.Elements[8] + this.Elements[4] * other.Elements[9] +
this.Elements[8] * other.Elements[10];
newe[9] = this.Elements[1] * other.Elements[8] + this.Elements[5] * other.Elements[9] +
this.Elements[9] * other.Elements[10];
newe[10] = this.Elements[2] * other.Elements[8] + this.Elements[6] * other.Elements[9] +
this.Elements[10] * other.Elements[10];
newe[11] = 0;
newe[12] = this.Elements[0] * other.Elements[12] + this.Elements[4] * other.Elements[13] +
this.Elements[8] * other.Elements[14] + this.Elements[12];
newe[13] = this.Elements[1] * other.Elements[12] + this.Elements[5] * other.Elements[13] +
this.Elements[9] * other.Elements[14] + this.Elements[13];
newe[14] = this.Elements[2] * other.Elements[12] + this.Elements[6] * other.Elements[13] +
this.Elements[10] * other.Elements[14] + this.Elements[14];
newe[15] = 1;
this.Elements = newe;
return this;
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
public Matrix4X4 MultiplyM2(Matrix4X4 other, Matrix4X4 dest)
{
// Cache the matrix values (makes for huge speed increases!)
float a00 = Elements[0], a01 = Elements[1], a02 = Elements[2], a03 = Elements[3];
float a10 = Elements[4], a11 = Elements[5], a12 = Elements[6], a13 = Elements[7];
float a20 = Elements[8], a21 = Elements[9], a22 = Elements[10], a23 = Elements[11];
float a30 = Elements[12], a31 = Elements[13], a32 = Elements[14], a33 = Elements[15];
float b00 = other.Elements[0], b01 = other.Elements[1], b02 = other.Elements[2], b03 = other.Elements[3];
float b10 = other.Elements[4], b11 = other.Elements[5], b12 = other.Elements[6], b13 = other.Elements[7];
float b20 = other.Elements[8], b21 = other.Elements[9], b22 = other.Elements[10], b23 = other.Elements[11];
float b30 = other.Elements[12], b31 = other.Elements[13], b32 = other.Elements[14], b33 = other.Elements[15];
dest.Elements[0] = b00 * a00 + b01 * a10 + b02 * a20 + b03 * a30;
dest.Elements[1] = b00 * a01 + b01 * a11 + b02 * a21 + b03 * a31;
dest.Elements[2] = b00 * a02 + b01 * a12 + b02 * a22 + b03 * a32;
dest.Elements[3] = b00 * a03 + b01 * a13 + b02 * a23 + b03 * a33;
dest.Elements[4] = b10 * a00 + b11 * a10 + b12 * a20 + b13 * a30;
dest.Elements[5] = b10 * a01 + b11 * a11 + b12 * a21 + b13 * a31;
dest.Elements[6] = b10 * a02 + b11 * a12 + b12 * a22 + b13 * a32;
dest.Elements[7] = b10 * a03 + b11 * a13 + b12 * a23 + b13 * a33;
dest.Elements[8] = b20 * a00 + b21 * a10 + b22 * a20 + b23 * a30;
dest.Elements[9] = b20 * a01 + b21 * a11 + b22 * a21 + b23 * a31;
dest.Elements[10] = b20 * a02 + b21 * a12 + b22 * a22 + b23 * a32;
dest.Elements[11] = b20 * a03 + b21 * a13 + b22 * a23 + b23 * a33;
dest.Elements[12] = b30 * a00 + b31 * a10 + b32 * a20 + b33 * a30;
dest.Elements[13] = b30 * a01 + b31 * a11 + b32 * a21 + b33 * a31;
dest.Elements[14] = b30 * a02 + b31 * a12 + b32 * a22 + b33 * a32;
dest.Elements[15] = b30 * a03 + b31 * a13 + b32 * a23 + b33 * a33;
return this;
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
public void Copy(Matrix4X4 other)
{
other.Elements[0] = this.Elements[0];
other.Elements[1] = this.Elements[1];
other.Elements[2] = this.Elements[2];
other.Elements[3] = this.Elements[3];
other.Elements[4] = this.Elements[4];
other.Elements[5] = this.Elements[5];
other.Elements[6] = this.Elements[6];
other.Elements[7] = this.Elements[7];
other.Elements[8] = this.Elements[8];
other.Elements[9] = this.Elements[9];
other.Elements[10] = this.Elements[10];
other.Elements[11] = this.Elements[11];
other.Elements[12] = this.Elements[12];
other.Elements[13] = this.Elements[13];
other.Elements[14] = this.Elements[14];
other.Elements[15] = this.Elements[15];
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
public Matrix4X4 Inverse2(Matrix4X4 dest)
{
// Cache the matrix values (makes for huge speed increases!)
float a00 = Elements[0], a01 = Elements[1], a02 = Elements[2], a03 = Elements[3];
float a10 = Elements[4], a11 = Elements[5], a12 = Elements[6], a13 = Elements[7];
float a20 = Elements[8], a21 = Elements[9], a22 = Elements[10], a23 = Elements[11];
float a30 = Elements[12], a31 = Elements[13], a32 = Elements[14], a33 = Elements[15];
float b00 = a00 * a11 - a01 * a10;
float b01 = a00 * a12 - a02 * a10;
float b02 = a00 * a13 - a03 * a10;
float b03 = a01 * a12 - a02 * a11;
float b04 = a01 * a13 - a03 * a11;
float b05 = a02 * a13 - a03 * a12;
float b06 = a20 * a31 - a21 * a30;
float b07 = a20 * a32 - a22 * a30;
float b08 = a20 * a33 - a23 * a30;
float b09 = a21 * a32 - a22 * a31;
float b10 = a21 * a33 - a23 * a31;
float b11 = a22 * a33 - a23 * a32;
// Calculate the determinant (inlined to avoid double-caching)
float invDet = 1 / (b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06);
dest.Elements[0] = (a11 * b11 - a12 * b10 + a13 * b09) * invDet;
dest.Elements[1] = (-a01 * b11 + a02 * b10 - a03 * b09) * invDet;
dest.Elements[2] = (a31 * b05 - a32 * b04 + a33 * b03) * invDet;
dest.Elements[3] = (-a21 * b05 + a22 * b04 - a23 * b03) * invDet;
dest.Elements[4] = (-a10 * b11 + a12 * b08 - a13 * b07) * invDet;
dest.Elements[5] = (a00 * b11 - a02 * b08 + a03 * b07) * invDet;
dest.Elements[6] = (-a30 * b05 + a32 * b02 - a33 * b01) * invDet;
dest.Elements[7] = (a20 * b05 - a22 * b02 + a23 * b01) * invDet;
dest.Elements[8] = (a10 * b10 - a11 * b08 + a13 * b06) * invDet;
dest.Elements[9] = (-a00 * b10 + a01 * b08 - a03 * b06) * invDet;
dest.Elements[10] = (a30 * b04 - a31 * b02 + a33 * b00) * invDet;
dest.Elements[11] = (-a20 * b04 + a21 * b02 - a23 * b00) * invDet;
dest.Elements[12] = (-a10 * b09 + a11 * b07 - a12 * b06) * invDet;
dest.Elements[13] = (a00 * b09 - a01 * b07 + a02 * b06) * invDet;
dest.Elements[14] = (-a30 * b03 + a31 * b01 - a32 * b00) * invDet;
dest.Elements[15] = (a20 * b03 - a21 * b01 + a22 * b00) * invDet;
return this;
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
public Node()
{
this._needWordUpdate = true;
this._localRotationMatrix = Matrix4X4.Identity.Clone();
this._localScaleMatrix = Matrix4X4.Identity.Clone();
this._localTranslationMatrix = Matrix4X4.Identity.Clone();
this._localTransformMatrix = Matrix4X4.Identity.Clone();
this._worldTransformation = new Matrix4X4(null);
this.LocalTranslation = new Vector3(null);
this.LocalScale = new Vector3(null);
this.LocalRotation = new Vector3(null);
this.Pivot = new Vector3(null);
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
private void UpdateWorldTransformation()
{
/*this._localScaleMatrix.MultiplyM2(this._localRotationMatrix, this._localTransformMatrix);
this._localTransformMatrix.MultiplyM2(this._localTranslationMatrix, this._localTransformMatrix);*/
if (this.Animation != null) {
this._localTranslationMatrix.SetTranslate3(
this.Animation.TranslateX[this.Animation.CurrentFrame] + this.LocalTranslation.Elements[0],
this.Animation.TranslateY[this.Animation.CurrentFrame] + this.LocalTranslation.Elements[1],
this.Animation.TranslateZ[this.Animation.CurrentFrame] + this.LocalTranslation.Elements[2]);
this._localScaleMatrix.SetScale3(
this.Animation.ScaleX[this.Animation.CurrentFrame] + this.LocalScale.Elements[0],
this.Animation.ScaleY[this.Animation.CurrentFrame] + this.LocalScale.Elements[1],
this.Animation.ScaleZ[this.Animation.CurrentFrame] + this.LocalScale.Elements[2]);
this._localRotationMatrix.SetRotation3(
this.Animation.RotateX[this.Animation.CurrentFrame] + this.LocalRotation.Elements[0],
this.Animation.RotateY[this.Animation.CurrentFrame] + this.LocalRotation.Elements[1],
this.Animation.RotateZ[this.Animation.CurrentFrame] + this.LocalRotation.Elements[2]
);
}
this._localTranslationMatrix.Copy(this._localTransformMatrix);
this._localTransformMatrix.MultiplyM2(this._pivotMatrix, this._localTransformMatrix);
this._localTransformMatrix.MultiplyM2(this._localRotationMatrix, this._localTransformMatrix);
this._localTransformMatrix.MultiplyM2(this._inversePivotMatrix, this._localTransformMatrix);
this._localTransformMatrix.MultiplyM2(this._localScaleMatrix, this._localTransformMatrix);
if (this.Parent != null)
//this._localTransformMatrix.MultiplyM2(this.Parent.World, this._worldTransformation);
this.Parent.World.MultiplyM2(this._localTransformMatrix, this._worldTransformation);
else
this._worldTransformation = this._localTransformMatrix;
this._needWordUpdate = false;
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
private void RenderOpaqueMesh(Node node, Matrix4X4 mv, Matrix4X4 nv, int vertexLength, IShaderBinder binder)
{
/*check for material*/
MaterialComponent materialComponent = (MaterialComponent)node.Components[Component.MaterialComponent];
if (materialComponent == null) {
this.DebugLog("Cannot render node [" + node.Id + "] : material not found.");
return;
}
/*get the actual objects*/
MaterialItem material = (MaterialItem)this.Library.GetResource(materialComponent.MaterialHandle);
binder.BindGeometryMaterial(material);
binder.BindGeometryInstance(mv, nv);
/*due to the lack of mrt support, I have to use multiple passes for the same object*/
/*diffuse pass*/
this.SwitchRenderGroup(this._diffuseGroup);
this._context.DepthFunc(WebGLE.Lequal);
binder.BindGeometryPassNum(0);
this._context.DrawElements(WebGLE.Triangles, vertexLength, WebGLE.UnsignedShortT, 0);
/*position pass*/
this.SwitchRenderGroup(this._positionGroup);
this._context.DepthFunc(WebGLE.Equal);
binder.BindGeometryPassNum(1);
this._context.DrawElements(WebGLE.Triangles, vertexLength, WebGLE.UnsignedShortT, 0);
/*normal pass*/
this.SwitchRenderGroup(this._normalGroup);
binder.BindGeometryPassNum(2);
this._context.DrawElements(WebGLE.Triangles, vertexLength, WebGLE.UnsignedShortT, 0);
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
private void UpdateCullInfo(Matrix4X4 mv)
{
if (this._cullInfo.ModelView == null) {
this._cullInfo.LeftClip[0] = this._pMatrix.Elements[0] + this._pMatrix.Elements[3];
this._cullInfo.LeftClip[1] = this._pMatrix.Elements[4] + this._pMatrix.Elements[7];
this._cullInfo.LeftClip[2] = this._pMatrix.Elements[8] + this._pMatrix.Elements[11];
this._cullInfo.LeftClip[3] = this._pMatrix.Elements[12] + this._pMatrix.Elements[15];
this._cullInfo.RightClip[0] = -this._pMatrix.Elements[0] + this._pMatrix.Elements[3];
this._cullInfo.RightClip[1] = -this._pMatrix.Elements[4] + this._pMatrix.Elements[7];
this._cullInfo.RightClip[2] = -this._pMatrix.Elements[8] + this._pMatrix.Elements[11];
this._cullInfo.RightClip[3] = -this._pMatrix.Elements[12] + this._pMatrix.Elements[15];
this._cullInfo.BotClip[0] = this._pMatrix.Elements[1] + this._pMatrix.Elements[3];
this._cullInfo.BotClip[1] = this._pMatrix.Elements[5] + this._pMatrix.Elements[7];
this._cullInfo.BotClip[2] = this._pMatrix.Elements[9] + this._pMatrix.Elements[11];
this._cullInfo.BotClip[3] = this._pMatrix.Elements[13] + this._pMatrix.Elements[15];
this._cullInfo.TopClip[0] = -this._pMatrix.Elements[1] + this._pMatrix.Elements[3];
this._cullInfo.TopClip[1] = -this._pMatrix.Elements[5] + this._pMatrix.Elements[7];
this._cullInfo.TopClip[2] = -this._pMatrix.Elements[9] + this._pMatrix.Elements[11];
this._cullInfo.TopClip[3] = -this._pMatrix.Elements[13] + this._pMatrix.Elements[15];
this._cullInfo.NearClip[0] = this._pMatrix.Elements[2] + this._pMatrix.Elements[3];
this._cullInfo.NearClip[1] = this._pMatrix.Elements[6] + this._pMatrix.Elements[7];
this._cullInfo.NearClip[2] = this._pMatrix.Elements[10] + this._pMatrix.Elements[11];
this._cullInfo.NearClip[3] = this._pMatrix.Elements[14] + this._pMatrix.Elements[15];
this._cullInfo.FarClip[0] = -this._pMatrix.Elements[2] + this._pMatrix.Elements[3];
this._cullInfo.FarClip[1] = -this._pMatrix.Elements[6] + this._pMatrix.Elements[7];
this._cullInfo.FarClip[2] = -this._pMatrix.Elements[10] + this._pMatrix.Elements[11];
this._cullInfo.FarClip[3] = -this._pMatrix.Elements[14] + this._pMatrix.Elements[15];
}
this._cullInfo.ModelView = mv.Elements;
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
public void Initialize(float fov, float zNear, float zFar)
{
this.DisplayDebugInformation();
WebGLGraphics that = this;
/*render texture dimensions*/
this._renderTextureDim = this.SmallestPowerOfTwo(_canvas.Width);
this._renderViewport =
SystemCore.Environment.CreateFloat32ArrayFromArray(new float[] { _renderTextureDim, _renderTextureDim, });
this._shaderGroups = new Dictionary<string, ShaderGroup>();
/*rendering shaders*/
ShaderGroup phongShaderGroup = new ShaderGroup();
phongShaderGroup.Name = "phong";
phongShaderGroup.ShaderBinder = new PhongBinder(that.Library, that._context, phongShaderGroup);
SystemCore.ResourceManager.GetResource("/Data/Shader/phong_pass_geom.shader", null).ResourceChanged.Subscribe(
delegate(object sender, object args) {
Resource resource = (Resource) sender;
if (resource.Finished) {
phongShaderGroup.GeometryPassShader = (CompiledShader) resource.Data;
}
}, null);
SystemCore.ResourceManager.GetResource("/Data/Shader/phong_pass_prepost.shader", null).ResourceChanged.Subscribe(
delegate(object sender, object args) {
Resource resource = (Resource)sender;
if (resource.Finished) {
phongShaderGroup.PrePostProcessPassShader = (CompiledShader)resource.Data;
}
}, null);
SystemCore.ResourceManager.GetResource("/Data/Shader/phong_pass_light.shader", null).ResourceChanged.Subscribe(
delegate(object sender, object args) {
Resource resource = (Resource)sender;
if (resource.Finished) {
phongShaderGroup.LightPassShader = (CompiledShader)resource.Data;
}
}, null);
SystemCore.ResourceManager.GetResource("/Data/Shader/phong_pass_final.shader", null).ResourceChanged.Subscribe(
delegate(object sender, object args) {
Resource resource = (Resource)sender;
if (resource.Finished) {
phongShaderGroup.FinalPassShader = (CompiledShader)resource.Data;
}
}, null);
this.AddShaderGroup(phongShaderGroup);
this.ActiveShaderGroup = "phong";
/*core library - which contain things like light bounding meshes*/
Library.LoadLibrary("/Data/JSON/core.json").Finished.Subscribe(delegate(object sender, object args) {
Handle sphereHandle = new Handle();
sphereHandle.Collection = "core";
sphereHandle.Id = "point_light_sphere-lib";
that._lightSphereVolume = ((MeshItem)Library.GetResource(sphereHandle));
}, true);
/*enable webGL float texture extension*/
SystemCore.Logger.Log(this._context.GetExtension("OES_texture_float").ToString());
this.SetupFrameBuffers();
/*webgl render queues*/
this._opaqueMeshQueue = new List<List<Node>>();
this._transparentMeshQueue = new List<List<Node>>();
this._lightQueue = new Dictionary<int, List<Node>>();
/*camera*/
this._camera = new Node();
this._camera.AddComponent(new CameraComponent());
/*perspective*/
this._scaleMatrix = new Matrix4X4(null);
this._mvMatrix = new Matrix4X4(null);
this._vMatrix = new Matrix4X4(null);
this._nMatrix = new Matrix4X4(null);
this._pMatrix = Matrix4X4.MakePerspective(fov, 800.0f / 600.0f, zNear, zFar);
this._context.Viewport(0, 0, this._renderTextureDim, this._renderTextureDim);
this._context.EnableVertexAttribArray(0);
this._context.EnableVertexAttribArray(1);
this._context.EnableVertexAttribArray(2);
this._context.Enable(WebGLE.DepthTest);
this._context.Enable(WebGLE.CullFace);
this._context.BlendFunc(WebGLE.SrcAlpha, WebGLE.One);
/*occlusion*/
this._cullInfo = new CullInfo();
/*post process effects*/
this._effects = new List<IPostProcessEffect>();
/*active texture targets*/
this._activeTextureTarget = new List<int>();
this._activeTextureTarget[0] = WebGLE.Texture0;
this._activeTextureTarget[1] = WebGLE.Texture1;
this._activeTextureTarget[2] = WebGLE.Texture2;
/*I don't need any more for now*/
}
public void BindLight(Vector3 lightPos, LightItem light, Matrix4X4 mvMatrix, Matrix4X4 pMatrix)
{
if (this._parent.LightPassShader == null) return;
/*uniforms*/
this._graphics.UniformMatrix4fv(_parent.LightPassShader.Uniforms["uMVMatrix"], false, mvMatrix.Elements);
this._graphics.UniformMatrix4fv(_parent.LightPassShader.Uniforms["uPMatrix"], false, pMatrix.Elements);
this._graphics.Uniform3f(_parent.LightPassShader.Uniforms["uLightPos"], lightPos.Elements[0], lightPos.Elements[1], lightPos.Elements[2]);
this._graphics.Uniform3f(_parent.LightPassShader.Uniforms["uLightColor"], ((float[])light.Properties["color"])[0],
((float[])light.Properties["color"])[1], ((float[])light.Properties["color"])[2]);
this._graphics.Uniform1i(_parent.LightPassShader.Uniforms["uLightType"], light.LightType);
this._graphics.Uniform1f(_parent.LightPassShader.Uniforms["uLightIntensity"], (float)light.Properties["intensity"]);
}
public void BindGeometryPass(Matrix4X4 pMatrix)
{
if (this._parent.GeometryPassShader == null) return;
this._graphics.UseProgram(this._parent.GeometryPassShader.ShaderProgram);
/*bind constant matricees*/
this._graphics.UniformMatrix4fv(this._parent.GeometryPassShader.Uniforms["uPMatrix"], false, pMatrix.Elements);
}
public void BindGeometryInstance(Matrix4X4 mvMatrix, Matrix4X4 nMatrix)
{
if (this._parent.GeometryPassShader == null) return;
/*matrix tranformation*/
this._graphics.UniformMatrix4fv(this._parent.GeometryPassShader.Uniforms["uMVMatrix"], false, mvMatrix.Elements);
this._graphics.UniformMatrix4fv(this._parent.GeometryPassShader.Uniforms["uNMatrix"], false, nMatrix.Elements);
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
public Matrix4X4 ToMat4x4()
{
Matrix4X4 ret = new Matrix4X4(null);
float x = Elements[0], y = Elements[1], z = Elements[2], w = Elements[3];
float x2 = x + x;
float y2 = y + y;
float z2 = z + z;
float xx = x * x2;
float xy = x * y2;
float xz = x * z2;
float yy = y * y2;
float yz = y * z2;
float zz = z * z2;
float wx = w * x2;
float wy = w * y2;
float wz = w * z2;
ret.Elements[0] = 1 - (yy + zz);
ret.Elements[1] = xy - wz;
ret.Elements[2] = xz + wy;
ret.Elements[3] = 0;
ret.Elements[4] = xy + wz;
ret.Elements[5] = 1 - (xx + zz);
ret.Elements[6] = yz - wx;
ret.Elements[7] = 0;
ret.Elements[8] = xz - wy;
ret.Elements[9] = yz + wx;
ret.Elements[10] = 1 - (xx + yy);
ret.Elements[11] = 0;
ret.Elements[12] = 0;
ret.Elements[13] = 0;
ret.Elements[14] = 0;
ret.Elements[15] = 1;
return ret;
}
