Esempio n. 1
0
        public FrameBufferSurface(Size size)
        {
            mDisplay = Display.Impl as SDX_Display;
            mDevice  = mDisplay.D3D_Device;
            mSize    = size;

            try
            {
                mTexture = new Texture(mDevice.Device, mSize.Width, mSize.Height,
                                       0, Usage.RenderTarget, Format.A8R8G8B8, Pool.Default);
            }
            catch
            {
                Size newSize = SDX_Surface.NextPowerOfTwo(mSize);

                mTexture = new Texture(mDevice.Device, newSize.Width, newSize.Height,
                                       0, Usage.RenderTarget, Format.A8R8G8B8, Pool.Default);
            }

            mRenderTarget = mTexture.GetSurfaceLevel(0);

            mAgateSurface = new SDX_Surface(new AgateLib.Utility.Ref <Texture>(mTexture),
                                            new Rectangle(Point.Empty, Size));

            //SetHasDepthStencil(
        }
Esempio n. 2
0
        public SDX_Surface()
        {
            mDisplay = Display.Impl as SDX_Display;
            mDevice  = mDisplay.D3D_Device;

            InitVerts();
        }
Esempio n. 3
0
        public SDX_Surface(Size size)
        {
            mSrcRect = new Rectangle(new Point(0, 0), size);

            mDisplay = Display.Impl as SDX_Display;
            mDevice  = mDisplay.D3D_Device;

            mTexture = new Ref <Texture>(new Texture(mDevice.Device, size.Width, size.Height, 1, Usage.None,
                                                     Format.A8R8G8B8, Pool.Managed));

            RenderToSurface render = new RenderToSurface(mDevice.Device, size.Width, size.Height,
                                                         Format.A8R8G8B8, Format.D16);

            Viewport v = new Viewport(0, 0, size.Width, size.Height);

            render.BeginScene(mTexture.Value.GetSurfaceLevel(0), v);
            mDevice.Clear(ClearFlags.Target, Color.FromArgb(0, 0, 0, 0).ToArgb(), 1.0f, 0);
            render.EndScene(Filter.None);

            render.Dispose();
            render = null;

            mTextureSize = mSrcRect.Size;

            InitVerts();
        }
Esempio n. 4
0
        public SDX_IndexBuffer(SDX_Display disp, IndexBufferType type, int count)
        {
            mDisplay = disp;
            mType    = type;
            mCount   = count;

            CreateIndexBuffer();
        }
Esempio n. 5
0
        public SDX_Surface(Ref <Texture> texture, Rectangle sourceRect)
        {
            mSrcRect = sourceRect;

            mDisplay = Display.Impl as SDX_Display;
            mDevice  = mDisplay.D3D_Device;

            mTexture = new Ref <Texture>(texture);

            mTextureSize = new Size(mTexture.Value.GetSurfaceLevel(0).Description.Width,
                                    mTexture.Value.GetSurfaceLevel(0).Description.Height);

            InitVerts();
        }
Esempio n. 6
0
        public SDX_Surface(Stream stream)
        {
            mDisplay = Display.Impl as SDX_Display;
            mDevice  = mDisplay.D3D_Device;

            if (mDevice == null)
            {
                throw new Exception("Error: It appears that AgateLib has not been initialized yet.  Have you created a DisplayWindow?");
            }

            LoadFromStream(stream);

            InitVerts();
        }
        public FrameBufferWindow(Size size, SwapChain swap, AgateLib.DisplayLib.DisplayWindow attachedWindow, Direct3D.Surface backBuffer, Direct3D.Surface backDepthStencil)
        {
            mDisplay        = (SDX_Display)AgateLib.DisplayLib.Display.Impl;
            mAttachedWindow = attachedWindow;

            mSize             = size;
            mSwap             = swap;
            mBackBuffer       = backBuffer;
            mBackDepthStencil = backDepthStencil;

            if (mBackDepthStencil != null)
            {
                SetHasDepthStencil(mBackDepthStencil.Description.Format);
            }
        }
        public SDX_DisplayWindow(DisplayWindow owner, CreateWindowParams windowParams)
        {
            mChoosePosition = windowParams.WindowPosition;
            mOwner          = owner;

            if (windowParams.RenderToControl)
            {
                if (typeof(Control).IsAssignableFrom(windowParams.RenderTarget.GetType()) == false)
                {
                    throw new ArgumentException("The specified render target does not derive from System.Windows.Forms.Control");
                }

                mRenderTarget = (Control)windowParams.RenderTarget;

                mIsFullscreen = false;
                mChooseWidth  = mRenderTarget.ClientSize.Width;
                mChooseHeight = mRenderTarget.ClientSize.Height;

                mDisplay = Display.Impl as SDX_Display;
                mDisplay.Initialize(this, windowParams);
                mDisplay.VSyncChanged += new EventHandler(mDisplay_VSyncChanged);
            }
            else
            {
                if (string.IsNullOrEmpty(windowParams.IconFile) == false)
                {
                    mIcon = new Drawing.Icon(windowParams.IconFile);
                }

                mTitle        = windowParams.Title;
                mIsFullscreen = windowParams.IsFullScreen;
                mChooseWidth  = windowParams.Width;
                mChooseHeight = windowParams.Height;
                mChooseResize = windowParams.IsResizable;
                mHasFrame     = windowParams.HasFrame;

                CreateWindow(mIsFullscreen);

                mDisplay = Display.Impl as SDX_Display;
                mDisplay.Initialize(this, windowParams);
                mDisplay.VSyncChanged += new EventHandler(mDisplay_VSyncChanged);
            }

            AttachEvents();
            CreateBackBuffer(mIsFullscreen);
        }
Esempio n. 9
0
        public SDX_VertexBuffer(SDX_Display display, VertexLayout layout, int vertexCount)
        {
            mDisplay = display;
            mCount   = vertexCount;

            mDeclaration = CreateVertexDeclaration(mDisplay.D3D_Device.Device, layout);
            Direct3D.VertexFormat mFormats = CreateVertexFormat(layout);

            mLayout = layout;

            mBuffer = new SlimDX.Direct3D9.VertexBuffer(
                mDisplay.D3D_Device.Device,
                vertexCount * layout.VertexSize,
                SlimDX.Direct3D9.Usage.WriteOnly,
                mFormats,
                Direct3D.Pool.Managed);
        }
Esempio n. 10
0
        public SDX_Surface(string fileName)
        {
            mFileName = fileName;

            mDisplay = Display.Impl as SDX_Display;
            mDevice  = mDisplay.D3D_Device;

            if (mDevice == null)
            {
                throw new Exception("Error: It appears that AgateLib has not been initialized yet.  Have you created a DisplayWindow?");
            }

            LoadFromFile();

            //mDevice.Device.DeviceReset += new EventHandler(mDevice_DeviceReset);

            InitVerts();
        }
Esempio n. 11
0
        public void Flush()
        {
            if (mVertPointer == 0)
            {
                return;
            }

            mDevice.SetDeviceStateTexture(mTexture);
            mDevice.AlphaBlend     = mAlphaBlend;
            mDevice.AlphaArgument1 = TextureArgument.Texture;
            mDevice.AlphaArgument2 = TextureArgument.Diffuse;
            mDevice.AlphaOperation = TextureOperation.Modulate;

            mDevice.SetVertexDeclarationForSurfaces();

            SDX_Display display = (SDX_Display)Display.Impl;

            DoDraw(null);

            mVertPointer  = 0;
            mIndexPointer = 0;
        }
Esempio n. 12
0
 public HlslCompiler(SDX_Display display)
 {
     mDisplay = display;
 }
Esempio n. 13
0
 public HlslEffect(Direct3D.Effect effect)
 {
     mDisplay = (SDX_Display)Display.Impl;
     mEffect  = effect;
 }