public override void Render(SSRenderConfig renderConfig)
{
if (textures == null) return;
base.Render(renderConfig);
GL.MatrixMode(MatrixMode.Modelview);
GL.ActiveTexture(TextureUnit.Texture0);
GL.Enable(EnableCap.Texture2D);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS,
(int)TextureWrapMode.Clamp);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT,
(int)TextureWrapMode.Clamp);
Matrix4 scaleAndPosMat = Matrix4.CreateScale(this.Scale)
* Matrix4.CreateTranslation(0f, 0f, -this.Scale.X/2f);
for (int i = 0; i < (int)Face.NumFaces; ++i) {
//for (int i = 0; i < 1; ++i) {
var tex = textures [i];
if (tex != null) {
var mvMat = scaleAndPosMat * orientations [i] * renderConfig.invCameraViewMatrix;
GL.LoadMatrix(ref mvMat);
GL.BindTexture(TextureTarget.Texture2D, textures [i].TextureID);
SSTexturedQuad.singleFaceInstance.drawSingle(renderConfig, PrimitiveType.Triangles);
}
}
}
public override void Render(SSRenderConfig renderConfig)
{
if (_burningObject != null) {
this.worldMat = _burningObject.worldMat;
}
base.Render(renderConfig);
}
public override void Render(SSRenderConfig renderConfig)
{
if (_attachTo != null && !_attachTo.renderState.toBeDeleted)
{
this.worldMat = _attachTo.worldMat;
}
base.Render(renderConfig);
}
public void setupInput()
{
// hook mouse drag input...
this.MouseDown += (object sender, MouseButtonEventArgs e) => {
this.mouseButtonDown = true;
// cast ray for mouse click
var clientRect = new System.Drawing.Size(ClientRectangle.Width, ClientRectangle.Height);
Vector2 mouseLoc = new Vector2(e.X, e.Y);
SSRay ray = OpenTKHelper.MouseToWorldRay(
this.scene.ProjectionMatrix, this.scene.InvCameraViewMatrix, clientRect, mouseLoc);
// Console.WriteLine("mouse ({0},{1}) unproject to ray ({2})",e.X,e.Y,ray);
// scene.addObject(new SSObjectRay(ray));
selectedObject = scene.Intersect(ref ray);
};
this.MouseUp += (object sender, MouseButtonEventArgs e) => {
this.mouseButtonDown = false;
};
this.MouseMove += (object sender, MouseMoveEventArgs e) => {
if (this.mouseButtonDown)
{
// Console.WriteLine("mouse dragged: {0},{1}",e.XDelta,e.YDelta);
this.scene.ActiveCamera.MouseDeltaOrient(e.XDelta, e.YDelta);
// this.activeModel.MouseDeltaOrient(e.XDelta,e.YDelta);
}
};
this.MouseWheel += (object sender, MouseWheelEventArgs e) => {
// Console.WriteLine("mousewheel {0} {1}",e.Delta,e.DeltaPrecise);
SSCameraThirdPerson ctp = scene.ActiveCamera as SSCameraThirdPerson;
if (ctp != null)
{
ctp.followDistance += -e.DeltaPrecise;
}
};
this.KeyPress += (object sender, KeyPressEventArgs e) => {
switch (e.KeyChar)
{
case 'w':
scene.DrawWireFrameMode = SSRenderConfig.NextWireFrameMode(scene.DrawWireFrameMode);
updateWireframeDisplayText(scene.DrawWireFrameMode);
// if we need single-pass wireframes, set the GLSL uniform variable
shaderPgm.Activate();
shaderPgm.u_ShowWireframes = (scene.DrawWireFrameMode == WireframeMode.GLSL_SinglePass);
break;
}
};
}
public void renderCells(SSRenderConfig renderConfig, ssBVHNode <SSObject> n, ref SSAABB parentbox, int depth)
{
float nudge = 0f;
if (parentbox.Equals(n.box))
{
// attempt to nudge out of z-fighting
nudge = 0.2f;
}
if (highlightNodes.Contains(n))
{
if (n.gobjects == null)
{
GL.Color4(Color.FromArgb(255, 25, 25, 100));
}
else
{
GL.Color4(Color.Green);
}
}
else
{
if (n.gobjects == null)
{
GL.Color4(Color.FromArgb(255, 20, 20, 20));
}
else
{
GL.Color4(Color.DarkRed);
}
}
Vector3 nudgeVect = new Vector3(nudge);
Vector3 scale = n.box.Max - n.box.Min - 2f * nudgeVect;
Matrix4 mat = Matrix4.CreateScale(scale) * Matrix4.CreateTranslation(n.box.Min + nudgeVect);
GL.PushMatrix();
GL.MultMatrix(ref mat);
ibo.DrawElements(renderConfig, PrimitiveType.Lines, false);
GL.PopMatrix();
if (n.right != null)
{
renderCells(renderConfig, n.right, ref n.box, depth: depth + 1);
}
if (n.left != null)
{
renderCells(renderConfig, n.left, ref n.box, depth: depth + 1);
}
}
protected virtual void beforeRenderObjectHandler(Object obj, SSRenderConfig renderConfig)
{
if (autoWireframeMode)
{
if (obj == selectedObject)
{
renderConfig.drawWireframeMode = WireframeMode.GLSL_SinglePass;
}
else
{
renderConfig.drawWireframeMode = WireframeMode.None;
}
}
}
public override void Render(SSRenderConfig renderConfig)
{
var rc = cameraScene3d.renderConfig;
RectangleF clientRect = OpenTKHelper.GetClientRect();
var cameraPos
= (cameraScene3d.ActiveCamera != null) ? cameraScene3d.ActiveCamera.Pos
//: Vector3.Transform(-Vector3.UnitZ, rc.invCameraViewMatrix.Inverted()).Normalized();
: Vector3.Transform(Vector3.Zero, rc.invCameraViewMatrix.Inverted()).Normalized();
foreach (var updater in _spriteUpdaters)
{
updater.updateSprites(this.instanceData, ref clientRect,
ref cameraPos, ref rc.invCameraViewMatrix, ref rc.projectionMatrix);
}
base.Render(renderConfig);
}
public override void Render(SSRenderConfig renderConfig)
{
this.Pos = _missile.position;
base.Render(renderConfig);
SSShaderProgram.DeactivateAll();
GL.LineWidth(3f);
GL.Begin(PrimitiveType.Lines);
GL.Color4(Color4.LightCyan);
GL.Vertex3(Vector3.Zero);
GL.Vertex3(_missile._lataxDebug);
GL.Color4(Color4.Magenta);
GL.Vertex3(Vector3.Zero);
GL.Vertex3(_missile._hitTimeCorrAccDebug);
GL.End();
viewProjMat = renderConfig.invCameraViewMatrix * renderConfig.projectionMatrix;
}
public override void Render(SSRenderConfig renderConfig)
{
if (renderConfig.drawingShadowMap)
{
return;
}
base.Render(renderConfig);
SSShaderProgram.DeactivateAll();
GL.Disable(EnableCap.Texture2D);
GL.LineWidth(1.0f);
GL.MatrixMode(MatrixMode.Modelview);
ibo.Bind();
vbo.DrawBind(renderConfig);
this.renderCells(renderConfig, bvh.rootBVH, ref bvh.rootBVH.box, 0);
vbo.DrawUnbind();
ibo.Unbind();
}
public override void Render(SSRenderConfig renderConfig)
{
base.Render(renderConfig);
SSShaderProgram.DeactivateAll();
GL.Disable(EnableCap.Texture2D);
GL.Disable(EnableCap.Lighting);
GL.Enable(EnableCap.PointSmooth);
GL.PointSize(1.5f);
GL.Begin(BeginMode.Points);
for (int i = 0; i < this.numstars; i++)
{
GL.Color3(Color.FromArgb(vertices[i].DiffuseColor));
GL.Normal3(vertices[i].Normal);
GL.Vertex3(vertices[i].Position);
}
GL.End();
}
public override void renderMesh(SSRenderConfig renderConfig)
{
// apply animation channels
_hierarchy.applySkeletalControllers(_channelControllers);
SSAABB totalAABB = new SSAABB(float.PositiveInfinity, float.NegativeInfinity);
foreach (var sub in _renderSubMeshes)
{
SSAABB aabb = sub.ComputeVertices();
sub.renderMesh(renderConfig);
totalAABB.ExpandBy(aabb);
}
// update the bounding sphere
var sphere = totalAABB.ToSphere();
base.boundingSphereCenter = sphere.center;
base.boundingSphereRadius = sphere.radius;
NotifyMeshPositionOrSizeChanged();
}
public override void renderMesh(SSRenderConfig renderConfig)
{
SSShaderProgram.DeactivateAll();
GL.Disable(EnableCap.Texture2D);
GL.Disable(EnableCap.Lighting);
GL.Enable(EnableCap.PointSmooth);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
GL.PointSize(1.5f);
GL.Begin(BeginMode.Points);
for (int i = 0; i < this.numstars; i++)
{
GL.Color3(Color.FromArgb(vertices[i].DiffuseColor));
GL.Normal3(vertices[i].Normal);
GL.Vertex3(vertices[i].Position);
}
GL.End();
GL.Disable(EnableCap.Blend);
}
public override void Render(SSRenderConfig renderConfig)
{
if (_attachTo != null && !_attachTo.renderState.toBeDeleted) {
this.worldMat = _attachTo.worldMat;
}
base.Render(renderConfig);
}
public override void Render(SSRenderConfig renderConfig)
{
int queryResult = sunBillboard.OcclusionQueueryResult;
if (queryResult <= 0) return;
// Begin the quest to update VBO vertices
Matrix4 viewInverted = sunScene.renderConfig.invCameraViewMatrix.Inverted();
Vector3 viewRight = Vector3.Transform(new Vector3 (1f, 0f, 0f), viewInverted);
Vector3 viewUp = Vector3.Transform(new Vector3 (0f, 1f, 0f), viewInverted);
Vector3 sunRightMost = sunBillboard.Pos + viewRight.Normalized() * sunBillboard.Scale.X;
Vector3 sunTopMost = sunBillboard.Pos + viewUp.Normalized() * sunBillboard.Scale.Y;
int[] viewport = new int[4];
GL.GetInteger(GetPName.Viewport, viewport);
Vector2 screenOrig = new Vector2 (viewport [0], viewport [1]);
clientRect = new Vector2 (viewport [2], viewport [3]) / 2f;
screenCenter = screenOrig + clientRect / 2f;
sunSceneViewProj = sunScene.renderConfig.invCameraViewMatrix * sunScene.renderConfig.projectionMatrix;
Vector2 sunScreenPos = worldToScreen(sunBillboard.Pos);
Vector2 sunScreenRightMost = worldToScreen(sunRightMost);
Vector2 sunScreenTopMost = worldToScreen(sunTopMost);
Vector2 towardsCenter = screenCenter - sunScreenPos;
Vector2 tileVecBase = new Vector2 (sunScreenRightMost.X - sunScreenPos.X, sunScreenPos.Y - sunScreenTopMost.Y);
float sunFullEstimate = (float)Math.PI * tileVecBase.X * tileVecBase.Y;
float intensityFraction = Math.Min((float)queryResult / sunFullEstimate, 1f);
// modulate sprite size with the intensity fraction
tileVecBase *= Math.Min(1f / (1f - intensityFraction), 1.5f);
// allow simple scaling
tileVecBase.X *= Scale.X;
tileVecBase.Y *= Scale.Y;
for (int i = 0; i < numElements; ++i) {
//assign positions
Vector2 center = sunScreenPos + towardsCenter * 2.5f / (float)numElements * (float)i;
Vector2 tileVec = tileVecBase * spriteScales [i];
int baseIdx = i * 4;
vertices [baseIdx].Position.X = center.X - tileVec.X;
vertices [baseIdx].Position.Y = center.Y - tileVec.Y;
vertices [baseIdx+1].Position.X = center.X + tileVec.X;
vertices [baseIdx+1].Position.Y = center.Y - tileVec.Y;
vertices [baseIdx+2].Position.X = center.X + tileVec.X;
vertices [baseIdx+2].Position.Y = center.Y + tileVec.Y;
vertices [baseIdx+3].Position.X = center.X - tileVec.X;
vertices [baseIdx+3].Position.Y = center.Y + tileVec.Y;
}
Mesh.UpdateVertices(vertices);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
SSShaderProgram.DeactivateAll(); // disable shaders
// modulate color alpha with the intensity fraction
this.MainColor = sunBillboard.MainColor;
this.MainColor.A = intensityFraction;
// now, actually draw
base.Render(renderConfig);
}
public override void Render (SSRenderConfig renderConfig)
{
this.Pos = _missile.position;
base.Render(renderConfig);
SSShaderProgram.DeactivateAll();
GL.LineWidth(3f);
GL.Begin(PrimitiveType.Lines);
GL.Color4(Color4.LightCyan);
GL.Vertex3(Vector3.Zero);
GL.Vertex3(_missile._lataxDebug);
GL.Color4(Color4.Magenta);
GL.Vertex3(Vector3.Zero);
GL.Vertex3(_missile._hitTimeCorrAccDebug);
GL.End();
viewProjMat = renderConfig.invCameraViewMatrix * renderConfig.projectionMatrix;
}
public override void Render(SSRenderConfig renderConfig)
{
int queryResult = sunBillboard.OcclusionQueueryResult;
if (queryResult <= 0)
{
return;
}
// Begin the quest to update VBO vertices
Matrix4 viewInverted = sunScene.renderConfig.invCameraViewMatrix.Inverted();
Vector3 viewRight = Vector3.Transform(new Vector3(1f, 0f, 0f), viewInverted);
Vector3 viewUp = Vector3.Transform(new Vector3(0f, 1f, 0f), viewInverted);
Vector3 sunRightMost = sunBillboard.Pos + viewRight.Normalized() * sunBillboard.Scale.X;
Vector3 sunTopMost = sunBillboard.Pos + viewUp.Normalized() * sunBillboard.Scale.Y;
int[] viewport = new int[4];
GL.GetInteger(GetPName.Viewport, viewport);
Vector2 screenOrig = new Vector2(viewport [0], viewport [1]);
clientRect = new Vector2(viewport [2], viewport [3]) / 2f;
screenCenter = screenOrig + clientRect / 2f;
sunSceneViewProj = sunScene.renderConfig.invCameraViewMatrix * sunScene.renderConfig.projectionMatrix;
Vector2 sunScreenPos = worldToScreen(sunBillboard.Pos);
Vector2 sunScreenRightMost = worldToScreen(sunRightMost);
Vector2 sunScreenTopMost = worldToScreen(sunTopMost);
Vector2 towardsCenter = screenCenter - sunScreenPos;
Vector2 tileVecBase = new Vector2(sunScreenRightMost.X - sunScreenPos.X, sunScreenPos.Y - sunScreenTopMost.Y);
float sunFullEstimate = (float)Math.PI * tileVecBase.X * tileVecBase.Y;
float intensityFraction = Math.Min((float)queryResult / sunFullEstimate, 1f);
// modulate sprite size with the intensity fraction
tileVecBase *= Math.Min(1f / (1f - intensityFraction), 1.5f);
// allow simple scaling
tileVecBase.X *= Scale.X;
tileVecBase.Y *= Scale.Y;
for (int i = 0; i < numElements; ++i)
{
//assign positions
Vector2 center = sunScreenPos + towardsCenter * 2.5f / (float)numElements * (float)i;
Vector2 tileVec = tileVecBase * spriteScales [i];
int baseIdx = i * 4;
vertices [baseIdx].Position.X = center.X - tileVec.X;
vertices [baseIdx].Position.Y = center.Y - tileVec.Y;
vertices [baseIdx + 1].Position.X = center.X + tileVec.X;
vertices [baseIdx + 1].Position.Y = center.Y - tileVec.Y;
vertices [baseIdx + 2].Position.X = center.X + tileVec.X;
vertices [baseIdx + 2].Position.Y = center.Y + tileVec.Y;
vertices [baseIdx + 3].Position.X = center.X - tileVec.X;
vertices [baseIdx + 3].Position.Y = center.Y + tileVec.Y;
}
Mesh.UpdateVertices(vertices);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
SSShaderProgram.DeactivateAll(); // disable shaders
// modulate color alpha with the intensity fraction
this.MainColor = sunBillboard.MainColor;
this.MainColor.A = intensityFraction;
// now, actually draw
base.Render(renderConfig);
}
public override void Render(SSRenderConfig renderConfig)
{
var beam = _laser.beam(_beamId);
if (beam == null) return;
base.Render (renderConfig);
// step: setup render settings
SSShaderProgram.DeactivateAll ();
GL.ActiveTexture (TextureUnit.Texture0);
GL.Enable (EnableCap.Texture2D);
var laserParams = _laser.parameters;
var startView = Vector3.Transform(beam.startPos, renderConfig.invCameraViewMatrix);
var endView = Vector3.Transform (beam.endPos, renderConfig.invCameraViewMatrix);
var middleView = (startView + endView) / 2f;
// step: draw middle section:
Vector3 diff = endView - startView;
float diff_xy = diff.Xy.LengthFast;
float phi = -(float)Math.Atan2 (diff.Z, diff_xy);
float theta = (float)Math.Atan2 (diff.Y, diff.X);
Matrix4 backgroundOrientMat = Matrix4.CreateRotationY (phi) * Matrix4.CreateRotationZ (theta);
Matrix4 middlePlacementMat = backgroundOrientMat * Matrix4.CreateTranslation (middleView);
//Matrix4 startPlacementMat = Matrix4.CreateTranslation (startView);
float laserLength = diff.LengthFast;
float middleWidth = laserParams.middleBackgroundWidth * _laser.envelopeIntensity;
Vector3 cameraDir = Vector3.Transform(
-Vector3.UnitZ, _cameraScene.renderConfig.invCameraViewMatrix).Normalized();
float dot = Vector3.Dot (cameraDir, _laser.direction());
dot = Math.Max (dot, 0f);
float interferenceWidth = middleWidth * laserParams.middleInterferenceScale;
GL.Color4 (1f, 1f, 1f, beam.periodicIntensity * beam.periodicIntensity);
_updateMiddleMesh (laserLength, middleWidth);
#if true
// stretched middle background sprite
if (middleBackgroundSprite != null) {
_updateMiddleMesh (laserLength, middleWidth);
GL.Material(MaterialFace.Front, MaterialParameter.Emission, laserParams.backgroundColor);
GL.BindTexture (TextureTarget.Texture2D, middleBackgroundSprite.TextureID);
foreach (var oriX in xOrientationPresets)
{
Matrix4 rotated = oriX * middlePlacementMat;
GL.LoadMatrix (ref rotated);
_middleMesh.renderMesh (renderConfig);
}
}
#endif
#if true
// stretched middle overlay sprite
if (middleOverlayTexture != null) {
GL.Material(MaterialFace.Front, MaterialParameter.Emission, laserParams.overlayColor);
GL.BindTexture (TextureTarget.Texture2D, middleOverlayTexture.TextureID);
_middleMesh.renderMesh (renderConfig);
foreach (var oriX in xOrientationPresets)
{
Matrix4 rotated = oriX * middlePlacementMat;
GL.LoadMatrix (ref rotated);
_middleMesh.renderMesh (renderConfig);
}
}
#endif
#if true
// interference sprite with a moving U-coordinate offset
if (laserParams.middleInterferenceScale > 0f && interferenceTexture != null)
{
_updateInterfernenceVertices(laserLength, interferenceWidth);
GL.Material(MaterialFace.Front, MaterialParameter.Emission, laserParams.middleInterferenceColor);
//GL.BindTexture(TextureTarget.Texture2D, interferenceSprite.TextureID);
GL.BindTexture(TextureTarget.Texture2D, interferenceTexture.TextureID);
var scaleMat = Matrix4.CreateScale(laserLength + middleWidth/2f, interferenceWidth, 1f);
foreach (var oriX in xOrientationPresets) {
Matrix4 rotated = scaleMat * oriX * middlePlacementMat;
GL.LoadMatrix(ref rotated);
_interferenceMesh.renderMesh(renderConfig);
}
}
#endif
}
public override void Render(SSRenderConfig renderConfig)
{
var beam = _laser.beam(_beamId);
if (beam == null)
{
return;
}
base.Render(renderConfig);
// step: setup render settings
SSShaderProgram.DeactivateAll();
GL.ActiveTexture(TextureUnit.Texture0);
GL.Enable(EnableCap.Texture2D);
var laserParams = _laser.parameters;
var startView = Vector3.Transform(beam.startPosWorld, renderConfig.invCameraViewMatrix);
var endView = Vector3.Transform(beam.endPosWorld, renderConfig.invCameraViewMatrix);
var middleView = (startView + endView) / 2f;
// step: draw middle section:
Vector3 diff = endView - startView;
float diff_xy = diff.Xy.Length;
float phi = -(float)Math.Atan2(diff.Z, diff_xy);
float theta = (float)Math.Atan2(diff.Y, diff.X);
Matrix4 backgroundOrientMat = Matrix4.CreateRotationY(phi) * Matrix4.CreateRotationZ(theta);
Matrix4 middlePlacementMat = backgroundOrientMat * Matrix4.CreateTranslation(middleView);
//Matrix4 startPlacementMat = Matrix4.CreateTranslation (startView);
float laserLength = diff.Length;
float middleWidth = laserParams.middleBackgroundWidth * _laser.envelopeIntensity;
Vector3 cameraDir = Vector3.Transform(
-Vector3.UnitZ, _cameraScene.renderConfig.invCameraViewMatrix).Normalized();
float dot = Vector3.Dot(cameraDir, beam.directionWorld());
dot = Math.Max(dot, 0f);
float interferenceWidth = middleWidth * laserParams.middleInterferenceScale;
GL.Color4(1f, 1f, 1f, beam.periodicIntensity * beam.periodicIntensity);
_updateMiddleMesh(laserLength, middleWidth);
#if true
// stretched middle background sprite
if (middleBackgroundSprite != null)
{
GL.Material(MaterialFace.Front, MaterialParameter.Emission, laserParams.backgroundColor);
GL.BindTexture(TextureTarget.Texture2D, middleBackgroundSprite.TextureID);
foreach (var oriX in xOrientationPresets)
{
Matrix4 rotated = oriX * middlePlacementMat;
GL.LoadMatrix(ref rotated);
_middleMesh.renderMesh(renderConfig);
}
}
#endif
#if true
// stretched middle overlay sprite
if (middleOverlayTexture != null)
{
GL.Material(MaterialFace.Front, MaterialParameter.Emission, laserParams.overlayColor);
GL.BindTexture(TextureTarget.Texture2D, middleOverlayTexture.TextureID);
_middleMesh.renderMesh(renderConfig);
foreach (var oriX in xOrientationPresets)
{
Matrix4 rotated = oriX * middlePlacementMat;
GL.LoadMatrix(ref rotated);
_middleMesh.renderMesh(renderConfig);
}
}
#endif
#if true
// interference sprite with a moving U-coordinate offset
if (laserParams.middleInterferenceScale > 0f && interferenceTexture != null)
{
_updateInterfernenceVertices(laserLength, interferenceWidth);
GL.Material(MaterialFace.Front, MaterialParameter.Emission, laserParams.middleInterferenceColor);
//GL.BindTexture(TextureTarget.Texture2D, interferenceSprite.TextureID);
GL.BindTexture(TextureTarget.Texture2D, interferenceTexture.TextureID);
var scaleMat = Matrix4.CreateScale(laserLength + middleWidth / 2f, interferenceWidth, 1f);
foreach (var oriX in xOrientationPresets)
{
Matrix4 rotated = scaleMat * oriX * middlePlacementMat;
GL.LoadMatrix(ref rotated);
_interferenceMesh.renderMesh(renderConfig);
}
}
#endif
}
public void drawSingle(SSRenderConfig renderConfig, PrimitiveType primType)
{
renderMesh(renderConfig);
}
