public static void drawQuadTranslucent2d(Quad2d q, Color c)
{
Gl.glDisable(Gl.GL_CULL_FACE);
Gl.glDisable(Gl.GL_LIGHTING);
Gl.glEnable(Gl.GL_BLEND);
Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA);
Gl.glEnable(Gl.GL_POLYGON_SMOOTH);
Gl.glHint(Gl.GL_POLYGON_SMOOTH_HINT, Gl.GL_NICEST);
Gl.glColor4ub(c.R, c.G, c.B, 100);
Gl.glBegin(Gl.GL_POLYGON);
for (int i = 0; i < 4; ++i)
{
Gl.glVertex2dv(q.points3d[i].ToArray());
}
Gl.glEnd();
Gl.glColor3ub(c.R, c.G, c.B);
Gl.glLineWidth(2.0f);
Gl.glBegin(Gl.GL_LINES);
for (int i = 0; i < 4; ++i)
{
Gl.glVertex2dv(q.points3d[i].ToArray());
Gl.glVertex2dv(q.points3d[(i + 1) % 4].ToArray());
}
Gl.glEnd();
Gl.glEnable(Gl.GL_CULL_FACE);
Gl.glDisable(Gl.GL_BLEND);
Gl.glDisable(Gl.GL_POLYGON_SMOOTH);
}
}//selectMeshVertex
public void selectMeshEdges(Quad2d q)
{
HalfEdge[] guideLines = this.mesh.Edges;
double[] vertexPos = this.mesh.VertexPos;
for (int i = 0; i < guideLines.Length; ++i)
{
int fromIdx = guideLines[i].FromIndex;
int toIdx = guideLines[i].ToIndex;
Vector3d vf = new Vector3d(vertexPos[fromIdx * 3],
vertexPos[fromIdx * 3 + 1],
vertexPos[fromIdx * 3 + 2]);
Vector3d vt = new Vector3d(vertexPos[toIdx * 3],
vertexPos[toIdx * 3 + 1],
vertexPos[toIdx * 3 + 2]);
Vector3d screenFrom = this.projectToScreen(vf);
Vector3d screenTo = this.projectToScreen(vt);
if (Quad2d.isPointInQuad(new Vector2d(screenFrom.x, screenFrom.y), q) ||
Quad2d.isPointInQuad(new Vector2d(screenTo.x, screenTo.y), q))
{
if (!this.unSelect)
{
if (!this.selectedEdges.Contains(i))
{
this.selectedEdges.Add(i);
}
}
else
{
this.selectedEdges.Remove(i);
}
}
}
}//selectMeshEdges
public void selectMouseMove(int mode, Quad2d q)
{
switch (mode)
{
case 1:
{
this.selectMeshVertex(q);
break;
}
case 2:
{
this.selectMeshEdges(q);
break;
}
case 3:
{
this.selectMeshFaces(q);
break;
}
default:
break;
}
}
public void init()
{
sunLight = new LightSun(new Vector3(0.1f, 0.125f, 0.2f) * 3f, this);
sunLight.lightAmbient = new Vector3(0.1f, 0.125f, 0.2f) * 0.5f;//new Vector3(0.2f, 0.125f, 0.1f);//new Vector3(0.1f, 0.14f, 0.3f);
sunLight.PointingDirection = Vector3.Normalize(new Vector3(674, -674, 1024));
sunFrameBuffer = gameWindow.framebufferCreator.createFrameBuffer("shadowFramebuffer", shadowRes * 2, shadowRes * 2, PixelInternalFormat.Rgba8, false);
sunInnerFrameBuffer = gameWindow.framebufferCreator.createFrameBuffer("shadowFramebuffer", shadowRes * 2, shadowRes * 2, PixelInternalFormat.Rgba8, false);
mFilter2d = new Quad2d(this);
mSkyModel = new Skybox(this, gameWindow);
mGroundPlane = new GroundPlane(this);
mGroundPlane.setMaterial("floor.xmf");
mGroundPlane.setMesh("water_plane.obj");
mGroundPlane.setMaterial("floor.xmf");
//need to be fixed -- cant be executed after voxel Manager creation.
if (Settings.Instance.video.Particles)
{
generateParticleSys();
}
voxelManager = new VoxelManager(this);
compositeMod.X = Settings.Instance.video.gamma;
particleAffectors.Add(new ParticleAffectorWind(new Vector3(1, -0.5f, 0) * 0.01f));
particleAffectors.Add(new ParticleAffectorFriction(0.1f));
particleAffectors.Add(new ParticleAffectorFloorKiller(waterLevel));
particleAffectors.Add(new ParticleAffectorLifeTimeKiller(this));
/*
* waterModel.setTextures(mTextureLoader.fromMixed(new int[]{
* TextureGroup.TYPE_FRAMEBUFFER,
* TextureGroup.TYPE_FROMFILE},
* new string[] {
* Convert.ToString(waterFramebuffer.ColorTexture),
* "noise.png"}));
*/
mGroundPlane.Position = new Vector3(0, waterLevel, 0);
//mGroundPlane.updateModelMatrix();
Matrix4 translate = Matrix4.CreateTranslation(0, -waterLevel * 2, 0);
Matrix4 invert = Matrix4.Scale(1, -1, 1);
Matrix4.Mult(ref translate, ref invert, out mWaterMatrix);
}
}//selectMeshEdges
public void selectMeshFaces(Quad2d q)
{
fixed(double *vertexPos = this.mesh.VertexPos)
{
fixed(int *faceIndex = this.mesh.FaceVertexIndex)
{
for (int i = 0, j = 0; i < this.mesh.FaceCount; ++i, j += 3)
{
Vector3d[] verts = { new Vector3d(vertexPos[faceIndex[j] * 3],
vertexPos[faceIndex[j] * 3 + 1],
vertexPos[faceIndex[j] * 3 + 2]),
new Vector3d(vertexPos[faceIndex[j + 1] * 3],
vertexPos[faceIndex[j + 1] * 3 + 1],
vertexPos[faceIndex[j + 1] * 3 + 2]),
new Vector3d(vertexPos[faceIndex[j + 2] * 3],
vertexPos[faceIndex[j + 2] * 3 + 1],
vertexPos[faceIndex[j + 2] * 3 + 2]) };
for (int k = 0; k < 3; ++k)
{
Vector3d v3 = this.projectToScreen(verts[k]);
Vector2d screen = new Vector2d(v3.x, v3.y);
if (Quad2d.isPointInQuad(screen, q))
{
if (!this.unSelect)
{
if (!this.selectedFaces.Contains(i))
{
this.selectedFaces.Add(i);
}
break;
}
else
{
this.selectedFaces.Remove(i);
break;
}
}
}
}
}
}
}//selectMeshFaces
public void selectMeshVertex(Quad2d q)
{
double[] vertexPos = this.mesh.VertexPos;
for (int i = 0, j = 0; i < this.mesh.VertexCount; ++i, j += 3)
{
Vector3d screen = this.projectToScreen(new Vector3d(vertexPos[j], vertexPos[j + 1], vertexPos[j + 2]));
if (Quad2d.isPointInQuad(new Vector2d(screen.x, screen.y), q))
{
if (!this.unSelect)
{
if (!this.selectedVertices.Contains(i))
{
this.selectedVertices.Add(i);
}
}
else
{
this.selectedVertices.Remove(i);
}
}
}
}//selectMeshVertex
public void CodeQuad2d(ref Quad2d v)
{
CodeV2d(ref v.P0); CodeV2d(ref v.P1); CodeV2d(ref v.P2); CodeV2d(ref v.P3);
}
public void CodeQuad2d(ref Quad2d v)
{
throw new NotImplementedException();
}
public void CodeQuad2d(ref Quad2d v)
{
AddValue(v.ToString());
}
protected override void OnLoad(System.EventArgs e)
{
//generate stopwatch
sw = new Stopwatch();
//set size of the render
virtual_size = Settings.Instance.video.CreateSizeVector(VideoSettings.Target.main);
state = new GameState();
string versionOpenGL = GL.GetString(StringName.Version);
log(versionOpenGL);
// make the Coursor disapear
Cursor.Hide();
// center it on the window
Cursor.Position = new Point(
(Bounds.Left + Bounds.Right) / 2,
(Bounds.Top + Bounds.Bottom) / 2);
// other state
GL.ClearColor(System.Drawing.Color.Black);
VSync = VSyncMode.On;
screenSize = new Vector2(Width, Height);
// create instances of necessary objects
textureLoader = new TextureLoader(this);
framebufferCreator = new FramebufferCreator(this);
meshLoader = new MeshLoader(this);
shaderLoader = new ShaderLoader(this);
materialLoader = new MaterialLoader(this);
templateLoader = new TemplateLoader(this);
mScene = new Scene(this);
// create gameInput
gameInput = new GameInput(mScene, Keyboard, Mouse);
// set files for displaying loading screen
shaderLoader.fromXmlFile("shaders\\composite.xsp");
shaderLoader.fromTextFile("shaders\\composite.vs", "shaders\\splash_shader.fs");
meshLoader.fromObj("models\\sprite_plane.obj");
textureLoader.fromPng("materials\\ultra_engine_back.png", true);
textureLoader.fromPng("materials\\ultra_engine_back_h.png", true);
materialLoader.fromXmlFile("materials\\composite.xmf");
//loading noise manualy so we can disable multisampling
textureLoader.fromPng("materials\\noise_pixel.png", false);
// load files for loading screen
textureLoader.LoadTextures();
meshLoader.loadMeshes();
shaderLoader.loadShaders();
materialLoader.loadMaterials();
// load files from cache
if (Settings.Instance.game.useCache)
{
meshLoader.readCacheFile();
//shaderLoader.readCacheFile();
//textureLoader.readCacheFile();
materialLoader.readCacheFile();
templateLoader.readCacheFile();
}
// setup 2d filter (loading screen)
splashFilter2d = new Quad2d(this);
// set time to zero
spawnTime = get_time();
}
