Esempio n. 1
0
 public void ClearDepthBuffer()
 {
     using (ScopedLock lLock = LockContext())
     {
         Gl.glClear(Gl.GL_DEPTH_BUFFER_BIT);
     }
 }
Esempio n. 2
0
 public void PopTransform()
 {
     using (ScopedLock lLock = LockContext())
     {
         Gl.glPopMatrix();
     }
 }
Esempio n. 3
0
 protected void SetViewPort(int xiWidth, int xiHeight)
 {
     using (ScopedLock lLock = LockContext())
     {
         Gl.glViewport(0, 0, xiWidth, xiHeight);
     }
 }
Esempio n. 4
0
 public void DisableLighting()
 {
     using (ScopedLock lLock = LockContext())
     {
         Gl.glDisable(Gl.GL_LIGHTING);
         Gl.glDisable(Gl.GL_COLOR_MATERIAL);
     }
 }
Esempio n. 5
0
 public void PushTransform(Matrix xiTransform)
 {
     using (ScopedLock lLock = LockContext())
     {
         Gl.glPushMatrix();
         Gl.glMultMatrixd(xiTransform.ToArray());
     }
 }
Esempio n. 6
0
 public void EnableLighting()
 {
     using (ScopedLock lLock = LockContext())
     {
         Gl.glEnable(Gl.GL_LIGHTING);
         Gl.glEnable(Gl.GL_COLOR_MATERIAL);
         Gl.glColorMaterial(Gl.GL_FRONT_AND_BACK, Gl.GL_AMBIENT_AND_DIFFUSE);
     }
 }
Esempio n. 7
0
        public void Clear()
        {
            using (ScopedLock lLock = LockContext())
            {
                Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
            }

            ResetCounters();
        }
Esempio n. 8
0
        public int SetLight(int xiLightId, Light xiLight)
        {
            int lGLLightId = GetLightId(xiLightId);

            using (ScopedLock lLock = LockContext())
            {
                Gl.glLightfv(
                    lGLLightId,
                    Gl.GL_POSITION,
                    new float[] {
                    (float)xiLight.Position.x,
                    (float)xiLight.Position.y,
                    (float)xiLight.Position.z,
                    1f
                });

                Gl.glLightfv(
                    lGLLightId,
                    Gl.GL_DIFFUSE,
                    new float[] {
                    (float)xiLight.DiffuseColor.R / 255,
                    (float)xiLight.DiffuseColor.G / 255,
                    (float)xiLight.DiffuseColor.B / 255,
                    (float)xiLight.DiffuseIntensity
                });

                Gl.glLightfv(
                    lGLLightId,
                    Gl.GL_AMBIENT,
                    new float[] {
                    (float)xiLight.AmbientColor.R / 255,
                    (float)xiLight.AmbientColor.G / 255,
                    (float)xiLight.AmbientColor.B / 255,
                    (float)xiLight.AmbientIntensity
                });

                Gl.glLightfv(
                    lGLLightId,
                    Gl.GL_SPECULAR,
                    new float[] {
                    (float)xiLight.SpecularColor.R / 255,
                    (float)xiLight.SpecularColor.G / 255,
                    (float)xiLight.SpecularColor.B / 255,
                    (float)xiLight.SpecularIntensity
                });

                Gl.glEnable(lGLLightId);
            }

            return(xiLightId);
        }
Esempio n. 9
0
 protected virtual void Init()
 {
     using (ScopedLock lLock = LockContext())
     {
         Gl.glEnable(Gl.GL_TEXTURE_2D);
         Gl.glShadeModel(Gl.GL_SMOOTH);
         Gl.glClearColor(0, 0, 0, 0.5f);
         Gl.glClearDepth(1);
         Gl.glEnable(Gl.GL_DEPTH_TEST);
         Gl.glDepthFunc(Gl.GL_LEQUAL);
         Gl.glHint(Gl.GL_PERSPECTIVE_CORRECTION_HINT, Gl.GL_NICEST);
         Gl.glColorMaterial(Gl.GL_FRONT_AND_BACK, Gl.GL_AMBIENT_AND_DIFFUSE);
     }
 }
Esempio n. 10
0
        public void ResetLights()
        {
            using (ScopedLock lLock = LockContext())
            {
                Gl.glDisable(Gl.GL_LIGHT0);
                Gl.glDisable(Gl.GL_LIGHT1);
                Gl.glDisable(Gl.GL_LIGHT2);
                Gl.glDisable(Gl.GL_LIGHT3);
                Gl.glDisable(Gl.GL_LIGHT4);
                Gl.glDisable(Gl.GL_LIGHT5);
                Gl.glDisable(Gl.GL_LIGHT6);
                Gl.glDisable(Gl.GL_LIGHT7);
            }

            mNextLight = 0;
        }
Esempio n. 11
0
        public void SetCamera(Camera xiCamera)
        {
            using (ScopedLock lLock = LockContext())
            {
                Gl.glMatrixMode(Gl.GL_PROJECTION);
                Gl.glLoadIdentity();

                int[] lViewPort = new int[4];
                Gl.glGetIntegerv(Gl.GL_VIEWPORT, lViewPort);

                if (mPickMode)
                {
                    Glu.gluPickMatrix((double)mPickX, (double)(lViewPort[3] - mPickY), 1, 1, lViewPort);
                }

                switch (xiCamera.ProjectionMode)
                {
                case eProjectionMode.Perspective:
                    Glu.gluPerspective(
                        xiCamera.Fov,
                        (double)(lViewPort[0] - lViewPort[3]) / (double)(lViewPort[3] - lViewPort[1]),
                        xiCamera.NearClip,
                        xiCamera.FarClip);
                    break;

                case eProjectionMode.Orthographic:
                    double lSize  = xiCamera.Position.GetPositionVector() * xiCamera.ZAxis;
                    double lRatio = (double)lViewPort[3] / (double)lViewPort[2];
                    Gl.glOrtho(
                        -lSize / 2,
                        lSize / 2,
                        -lSize * lRatio / 2,
                        lSize * lRatio / 2,
                        xiCamera.NearClip,
                        xiCamera.FarClip);
                    break;

                default:
                    throw new Exception("Unrecognised projection mode");
                }

                Gl.glMatrixMode(Gl.GL_MODELVIEW);
                Gl.glLoadMatrixd(xiCamera.Transform.Inverse().ToArray());
            }
        }
Esempio n. 12
0
        public void Detach()
        {
            if (mRenderingContext != IntPtr.Zero)
            {
                try
                {
                    using (ScopedLock lLock = ScopedLock.Lock(mRenderingContext))
                    {
                        if (Wgl.wglGetCurrentContext() == mRenderingContext)
                        {
                            if (!Wgl.wglMakeCurrent(IntPtr.Zero, IntPtr.Zero))
                            {
                                throw new Exception("Could not release rendering context");
                            }
                        }

                        lock (mRenderingContexts)
                        {
                            mRenderingContexts.Remove(mRenderingContext);
                            if (!Wgl.wglDeleteContext(mRenderingContext))
                            {
                                throw new Exception("Could not delete rendering context");
                            }
                        }
                    }
                }
                finally
                {
                    try
                    {
                        if (mSurface != null)
                        {
                            mSurface.Resize -= Surface_Resize;
                            mSurface.ReleaseDeviceContext -= Surface_ReleaseDeviceContext;
                            mSurface.Paint -= Surface_Paint;
                        }
                    }
                    finally
                    {
                        mSurface          = null;
                        mRenderingContext = IntPtr.Zero;
                    }
                }
            }
        }
Esempio n. 13
0
        public void RenderMesh(Mesh xiMesh, RenderOptions xiOptions)
        {
            if (mPickMode)
            {
                using (ScopedLock lLock = LockContext())
                {
                    Gl.glLoadName(mPickIndex);
                }
                mPickMeshes.Add(mPickIndex, xiMesh);
                ++mPickIndex;
            }

            DateTime lStart = DateTime.Now;

            RenderMeshInternal(xiMesh, xiOptions);

            mRenderTime += (DateTime.Now - lStart).Milliseconds;
            ++mMeshCount;
            mVertexCount += xiMesh.Vertices.Count;
        }
Esempio n. 14
0
        private static int LoadTexture(Bitmap xiTexture)
        {
            int lTextureId;

            lock (mRenderingContexts)
            {
                if (mRenderingContexts.Count == 0)
                {
                    throw new Exception("No rendering contexts exist");
                }

                Rectangle  rectangle = new Rectangle(0, 0, xiTexture.Width, xiTexture.Height);
                BitmapData lData     = xiTexture.LockBits(
                    new Rectangle(0, 0, xiTexture.Width, xiTexture.Height),
                    ImageLockMode.ReadOnly,
                    PixelFormat.Format24bppRgb);

                using (ScopedLock lLock = ScopedLock.Lock(mRenderingContexts[0]))
                {
                    Gl.glGenTextures(1, out lTextureId);

                    Gl.glBindTexture(Gl.GL_TEXTURE_2D, lTextureId);
                    Gl.glTexImage2D(
                        Gl.GL_TEXTURE_2D,
                        0,
                        Gl.GL_RGB8,
                        xiTexture.Width,
                        xiTexture.Height,
                        0,
                        Gl.GL_BGR,
                        Gl.GL_UNSIGNED_BYTE,
                        lData.Scan0);

                    Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);
                    Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);
                }

                xiTexture.UnlockBits(lData);
            }
            return(lTextureId);
        }
Esempio n. 15
0
        protected ScopedLock LockContext()
        {
            ScopedLock lLock = ScopedLock.Lock(mRenderingContext);

            try
            {
                if (Wgl.wglGetCurrentContext() != mRenderingContext)
                {
                    if (!Wgl.wglMakeCurrent(mSurface.DeviceContext, mRenderingContext))
                    {
                        throw new Exception("Could not set the rendering context");
                    }
                }
            }
            catch
            {
                lLock.Dispose();
                throw;
            }

            return(lLock);
        }
Esempio n. 16
0
        protected override void RenderMeshInternal(Mesh xiMesh, RenderOptions xiOptions)
        {
            using (ScopedLock lLock = LockContext())
            {
                RenderMode lMode = DefaultRenderMode;
                if (FixedRenderMode != RenderMode.Undefined)
                {
                    lMode = FixedRenderMode;
                }
                else if (xiMesh.RenderMode != RenderMode.Undefined)
                {
                    lMode = xiMesh.RenderMode;
                }

                switch (lMode)
                {
                case RenderMode.Points:
                    Gl.glPolygonMode(Gl.GL_FRONT_AND_BACK, Gl.GL_POINT);
                    Gl.glBindTexture(Gl.GL_TEXTURE_2D, 0);
                    break;

                case RenderMode.Wireframe:
                    Gl.glPolygonMode(Gl.GL_FRONT_AND_BACK, Gl.GL_LINE);
                    Gl.glBindTexture(Gl.GL_TEXTURE_2D, 0);
                    break;

                case RenderMode.Filled:
                case RenderMode.TranslucentFilled:
                    Gl.glPolygonMode(Gl.GL_FRONT_AND_BACK, Gl.GL_FILL);
                    Gl.glBindTexture(Gl.GL_TEXTURE_2D, 0);
                    break;

                default:
                case RenderMode.Textured:
                    Gl.glPolygonMode(Gl.GL_FRONT_AND_BACK, Gl.GL_FILL);
                    Gl.glBindTexture(Gl.GL_TEXTURE_2D, xiMesh.Texture);
                    break;
                }

                switch (xiMesh.PolygonMode)
                {
                case PolygonMode.Lines:
                    Gl.glBegin(Gl.GL_LINES);
                    break;

                case PolygonMode.Triangles:
                    Gl.glBegin(Gl.GL_TRIANGLES);
                    break;

                case PolygonMode.Quads:
                    Gl.glBegin(Gl.GL_QUADS);
                    break;

                default:
                    throw new Exception("Unrecognised polygon type");
                }

                foreach (Vertex lVertex in xiMesh.Vertices)
                {
                    if (lMode == RenderMode.TranslucentFilled)
                    {
                        Gl.glColor4d(
                            (double)lVertex.Color.R / 255,
                            (double)lVertex.Color.G / 255,
                            (double)lVertex.Color.B / 255,
                            (double)lVertex.Color.A / 255);
                    }
                    else
                    {
                        Gl.glColor3d(
                            (double)lVertex.Color.R / 255,
                            (double)lVertex.Color.G / 255,
                            (double)lVertex.Color.B / 255);
                    }

                    Gl.glNormal3d(lVertex.Normal.x, lVertex.Normal.y, lVertex.Normal.z);
                    Gl.glTexCoord2d(lVertex.TexCoordX, lVertex.TexCoordY);
                    Gl.glVertex3d(lVertex.Position.x, lVertex.Position.y, lVertex.Position.z);
                }

                Gl.glEnd();

                if ((xiOptions & RenderOptions.ShowNormals) == RenderOptions.ShowNormals)
                {
                    Gl.glBegin(Gl.GL_LINES);

                    Gl.glColor3d(0.0, 0.0, 1.0);

                    foreach (Vertex lVertex in xiMesh.Vertices)
                    {
                        Gl.glVertex3d(lVertex.Position.x, lVertex.Position.y, lVertex.Position.z);
                        Point lNormalEnd = lVertex.Position + 25 * lVertex.Normal;
                        Gl.glVertex3d(lNormalEnd.x, lNormalEnd.y, lNormalEnd.z);
                    }

                    Gl.glEnd();
                }
            }
        }
Esempio n. 17
0
        public Mesh Pick(int x, int y)
        {
            using (ScopedLock lLock = LockContext())
            {
                int lPickIndex = int.MinValue;

                try
                {
                    mPickMode = true;
                    mPickX    = x;
                    mPickY    = y;
                    mPickMeshes.Clear();
                    mPickIndex = 0;

                    int[] lPickBuffer = new int[512];

                    Gl.glSelectBuffer(lPickBuffer.Length, lPickBuffer);

                    Gl.glRenderMode(Gl.GL_SELECT);

                    Gl.glInitNames();
                    Gl.glPushName(0);

                    Gl.glMatrixMode(Gl.GL_PROJECTION);
                    Gl.glPushMatrix();
                    Gl.glMatrixMode(Gl.GL_MODELVIEW);

                    if (NextFrame != null)
                    {
                        NextFrame(this, new NextFrameArgs(true));
                    }

                    Gl.glMatrixMode(Gl.GL_PROJECTION);
                    Gl.glPopMatrix();
                    Gl.glMatrixMode(Gl.GL_MODELVIEW);

                    int lHits = Gl.glRenderMode(Gl.GL_RENDER);

                    int lDepth = int.MaxValue;
                    for (int ii = 0; ii < lHits; ++ii)
                    {
                        if (lPickBuffer[ii * 4 + 1] < lDepth)
                        {
                            lDepth     = lPickBuffer[ii * 4 + 1];
                            lPickIndex = lPickBuffer[ii * 4 + 3];
                        }
                    }
                }
                finally
                {
                    mPickMode = false;
                }

                if (mPickMeshes.ContainsKey(lPickIndex))
                {
                    return(mPickMeshes[lPickIndex]);
                }
                else
                {
                    return(null);
                }
            }
        }