Beispiel #1
0
 private void SaveTexture(Texture texture, int index)
 {
     using (var stream = BaseTexture.ToStream(texture, ImageFileFormat.Png))
         using (var sr = new BinaryReader(stream))
             using (var fs = new FileStream(string.Format("overlay_{0}_{1}.png", index, (n++)), FileMode.Create))
                 using (var sw = new BinaryWriter(fs))
                 {
                     byte[] buffer = new byte[512];
                     int    bytesRead;
                     while ((bytesRead = sr.Read(buffer, 0, buffer.Length)) > 0)
                     {
                         sw.Write(buffer, 0, bytesRead);
                     }
                 }
 }
        public void SetTexture(int sampler, BaseTexture texture)
        {
#if DEBUG_STATE_MANAGER
            var s = device.GetTexture(sampler);
            if (textures[sampler] != s)
            {
                throw new Exception("State inconsistent, " + textures[sampler] + " != " + s);
            }
#endif
            if (textures[sampler] != texture)
            {
                device.SetTexture(sampler, texture);
                textures[sampler] = texture;
            }
        }
Beispiel #3
0
        /// <summary>
        /// Mod_LoadBrushModel
        /// </summary>
        public void LoadBrushModel(BrushModelData mod, byte[] buffer)
        {
            mod.Load(mod.Name, buffer, (tx) =>
            {
                if (tx.name != null && tx.name.StartsWith("sky"))    // !Q_strncmp(mt->name,"sky",3))
                {
                    this.Host.RenderContext.WarpableTextures.InitSky(tx);
                }
                else
                {
                    tx.texture = BaseTexture.FromBuffer(
                        this.Host.Video.Device, tx.name, new ByteArraySegment(tx.pixels),
                        ( int )tx.width, ( int )tx.height, true, true);
                }
            },
                     (textureFile) =>
            {
                var lowerName = textureFile.ToLower( );

                if (this.Host.WadTextures.ContainsKey(lowerName))
                {
                    var wadFile = this.Host.WadTextures[lowerName];
                    var wad     = this.Host.WadFiles[wadFile];

                    return(wad.GetLumpBuffer(textureFile));
                }

                return(null);
            });

            //
            // set up the submodels (FIXME: this is confusing)
            //
            for (var i = 0; i < mod.NumSubModels; i++)
            {
                mod.SetupSubModel(ref mod.SubModels[i]);

                if (i < mod.NumSubModels - 1)
                {
                    // duplicate the basic information
                    var name = "*" + (i + 1).ToString( );
                    this.CurrentModel = this.FindName(name, ModelType.mod_brush);
                    this.CurrentModel.CopyFrom(mod);           // *loadmodel = *mod;
                    this.CurrentModel.Name = name;             //strcpy (loadmodel->name, name);
                    mod = ( BrushModelData )this.CurrentModel; //mod = loadmodel;
                }
            }
        }
Beispiel #4
0
        private static byte[] GetDdsData(Device device, Bitmap bitmap, bool withHeader)
        {
            byte[] result;

            var argb = GetArgb8888(bitmap, out var stride, out var width, out var height);
            var rgb  = Argb8888ToRgb565(argb, stride, width, height);

            using (var texture = new Texture(device, width, height, DefaultDdsMipLevels, Usage.None, Format.R5G6B5, Pool.Scratch)) {
                texture.LockRectangle(0, LockFlags.None, out var dataStream);

                dataStream.Write(rgb, 0, rgb.Length);

                texture.UnlockRectangle(0);

                using (var ds = BaseTexture.ToStream(texture, ImageFileFormat.Dds)) {
                    using (var memory = new MemoryStream()) {
                        var buffer = new byte[10240];
                        var read   = 1;

                        while (read > 0)
                        {
                            read = ds.Read(buffer, 0, buffer.Length);

                            if (read > 0)
                            {
                                memory.Write(buffer, 0, read);
                            }
                        }

                        result = memory.ToArray();
                    }
                }
            }

            if (!withHeader)
            {
                const int ddsHeaderSize = 0x80;

                var newArray = new byte[result.Length - ddsHeaderSize];

                Array.Copy(result, ddsHeaderSize, newArray, 0, newArray.Length);

                result = newArray;
            }

            return(result);
        }
 public void Reset()
 {
     states = new int[System.Enum.GetNames(typeof(RenderState)).Length * 2];
     for (int i = 0; i < states.Length; i++)
     {
         states[i] = -1;
     }
     samplerStates = new int[16, System.Enum.GetNames(typeof(SamplerState)).Length * 2];
     for (int x = 0; x < samplerStates.GetLength(0); x++)
     {
         for (int y = 0; y < samplerStates.GetLength(1); y++)
         {
             samplerStates[x, y] = -1;
         }
     }
     textures = new BaseTexture[16];
 }
Beispiel #6
0
        public static BaseModel Create(BaseDevice device, string identifier, BaseTexture texture, Type modelType, Type descType)
        {
            if (BaseModel.ModelPool.ContainsKey(identifier))
            {
                return(BaseModel.ModelPool[identifier]);
            }

            var desc = ( BaseAliasModelDesc )Activator.CreateInstance(descType);

            desc.Name    = identifier;
            desc.Texture = texture;

            var model = ( BaseModel )Activator.CreateInstance(modelType, device, desc);

            model.Initialise( );

            return(model);
        }
Beispiel #7
0
        protected void UpdateProperties(BaseTexture texture)
        {
            SurfaceDescription desc;
            Texture            tex = texture as Texture;

            if (tex != null)
            {
                desc = tex.GetLevelDescription(0);
            }
            else
            {
                CubeTexture ctex = texture as CubeTexture;
                desc = ctex.GetLevelDescription(0);
            }

            Width  = desc.Width;
            Height = desc.Height;
            Format = desc.Format;
        }
Beispiel #8
0
        private static void DrawSpriteMain(BaseTexture texture, CubeMapFace?face, ref RectangleF destination, bool scaleDestination, Rectangle?sourceRectangle, Color color, Vector2 rightVector, ref Vector2 origin, SpriteEffects effects, float depth)
        {
            if (m_screenshot != null && m_screenshot.IgnoreSprites)
            {
                return;
            }

            m_spriteBatch.DrawSprite(
                texture,
                face,
                ref destination,
                scaleDestination,
                sourceRectangle,
                color,
                rightVector,
                ref origin,
                effects,
                depth);
        }
Beispiel #9
0
        /// <summary>
        /// Draws the sub sprite with the given index from the atlas using the nine cut method
        /// This is mostly useful for gui elements like forms and buttons
        /// </summary>
        /// <param name="sb"></param>
        /// <param name="index"></param>
        /// <param name="dest"></param>
        /// <param name="source"></param>
        /// <param name="color"></param>
        /// <param name="destEdge"></param>
        /// <param name="sourceEdge"></param>
        public void DrawNineCut(SpriteBatch sb, string spriteDef, Rectangle dest, Rectangle?source = null, Color?color = null, int?destEdge = null, int?sourceEdge = null, Vector2?scale = null, Vector2?origin = null, float rotation = 0)
        {
            Rectangle def;
            bool      res = SpriteDefinitions.TryGetValue(spriteDef, out def);

            if (!res)
            {
                ConsoleManager.Instance.WriteLine($"Could not find sprite '{spriteDef}' in '{BaseTexture.Path}'");
                return;
            }

            if (source == null)
            {
                source = def;
            }

            Rectangle finalSource = new Rectangle(def.X + source.Value.X, def.Y + source.Value.Y, source.Value.Width, source.Value.Height);

            BaseTexture.DrawNineCut(sb, dest, finalSource, color, destEdge, sourceEdge, scale, origin, rotation);
        }
Beispiel #10
0
        public virtual void Draw(SpriteBatch spriteBatch)
        {
            if (!IsShow)
            {
                return;
            }

            if (IsClicked && ClickedTexture != null)
            {
                ClickedTexture.Draw(spriteBatch, ScreenPosition);
            }
            else if (IsMouveOver && MouseOverTexture != null)
            {
                MouseOverTexture.Draw(spriteBatch, ScreenPosition);
            }
            else if (BaseTexture != null)
            {
                BaseTexture.Draw(spriteBatch, ScreenPosition);
            }
        }
Beispiel #11
0
    private IEnumerable <Vector2> GetTileCenters(Texture2D distortedBaseMap)
    {
        TileCenterCounter[] centerCounters = new TileCenterCounter[MaxIndex];
        for (int i = 0; i < MaxIndex; i++)
        {
            centerCounters[i] = new TileCenterCounter();
        }

        for (int x = 0; x < BaseTexture.width; x++)
        {
            for (int y = 0; y < BaseTexture.height; y++)
            {
                Color pixel  = BaseTexture.GetPixel(x, y);
                int   index  = ToIndex(pixel);
                float xParam = (float)x / BaseTexture.width;
                float yParam = (float)y / BaseTexture.height;
                centerCounters[index].RegisterPixel(xParam, yParam);
            }
        }
        return(centerCounters.Select(item => item.GetTileCenter()));
    }
Beispiel #12
0
 public TextureBase(int cubeSize, bool renderTarget)
 {
     Framework.Instance.DeviceCreated += new Bonsai.Core.EventArgs.DeviceEventHandler(Instance_DeviceCreated);
     Framework.Instance.DeviceLost    += new EventHandler(Instance_DeviceLost);
     Framework.Instance.DeviceReset   += new Bonsai.Core.EventArgs.DeviceEventHandler(Instance_DeviceReset);
     this.lowLevel     = true;
     this.width        = cubeSize;
     this.height       = cubeSize;
     this.cubeMap      = true;
     this.fileName     = null;
     this.renderTarget = renderTarget;
     if (renderTarget)
     {
         this.texture = new CubeTexture(Framework.Instance.Device, cubeSize, 1, Usage.Dynamic,
                                        Framework.Instance.Device.PresentationParameters.BackBufferFormat, Pool.Default);
     }
     else
     {
         this.texture = new CubeTexture(Framework.Instance.Device, cubeSize, 1, Usage.Dynamic, Format.A8R8G8B8, Pool.Default);
     }
 }
Beispiel #13
0
 void Instance_DeviceReset(object sender, Bonsai.Core.EventArgs.DeviceEventArgs e)
 {
     if (lowLevel)
     {
         if (texture != null)
         {
             texture.Dispose();
             texture = null;
         }
         if (cubeMap)
         {
             if (renderTarget)
             {
                 this.texture = new CubeTexture(Framework.Instance.Device, width, 1, Usage.RenderTarget,
                                                Framework.Instance.Device.PresentationParameters.BackBufferFormat, Pool.Default);
             }
             else
             {
                 this.texture = new CubeTexture(Framework.Instance.Device, width, 1, Usage.Dynamic,
                                                Format.A8R8G8B8, Pool.Default);
             }
         }
         else
         {
             if (renderTarget)
             {
                 this.texture = new Texture(Framework.Instance.Device, width, height, 1, Usage.Dynamic, Format.A8R8G8B8, Pool.Default);
             }
             else
             {
                 this.texture = new Texture(Framework.Instance.Device, width, height, 1, Usage.RenderTarget,
                                            Framework.Instance.Device.PresentationParameters.BackBufferFormat, Pool.Default);
             }
         }
     }
     else
     {
         LoadTexture(folder);
     }
 }
Beispiel #14
0
        // beamlength
        // R_InitParticleTexture
        public void InitParticleTexture( )
        {
            var data = new byte[8 * 8 * 4];
            var i    = 0;

            for (var x = 0; x < 8; x++)
            {
                for (var y = 0; y < 8; y++, i += 4)
                {
                    data[i]     = 255;
                    data[i + 1] = 255;
                    data[i + 2] = 255;
                    data[i + 3] = ( byte )(ParticleDef._DotTexture[x, y] * 255);
                }
            }

            var uintData = new uint[data.Length / 4];

            Buffer.BlockCopy(data, 0, uintData, 0, data.Length);

            this.ParticleTexture = BaseTexture.FromBuffer(this.Device, "_Particles", uintData, 8, 8, false, true, "GL_LINEAR", "GL_MODULATE");
        }
Beispiel #15
0
        public override void DrawWaterPolyMultiTexture(byte[] lightMapData, BaseTexture texture, BaseTexture lightMapTexture, int lightMapTextureNumber, GLPoly p, double time)
        {
            GL.Enable(EnableCap.Texture2D);

            texture.Bind( );

            GL.TexEnv(TextureEnvTarget.TextureEnv, TextureEnvParameter.TextureEnvMode, ( int )TextureEnvMode.Replace);

            this.Device.EnableMultitexture( );

            lightMapTexture.BindLightmap((( GLTextureDesc )lightMapTexture.Desc).TextureNumber + lightMapTextureNumber);
            var i = lightMapTextureNumber;

            if (lightMapTexture.LightMapModified[i])
            {
                lightMapTexture.CommitLightmap(lightMapData, i);
            }

            GL.TexEnv(TextureEnvTarget.TextureEnv, TextureEnvParameter.TextureEnvMode, ( int )TextureEnvMode.Blend);
            GL.Begin(PrimitiveType.TriangleFan);

            var nv = new float[3];

            for (i = 0; i < p.numverts; i++)
            {
                var v = p.verts[i];
                GL.MultiTexCoord2(TextureUnit.Texture0, v[3], v[4]);
                GL.MultiTexCoord2(TextureUnit.Texture1, v[5], v[6]);

                nv[0] = ( float )(v[0] + 8 * Math.Sin(v[1] * 0.05 + time) * Math.Sin(v[2] * 0.05 + time));
                nv[1] = ( float )(v[1] + 8 * Math.Sin(v[0] * 0.05 + time) * Math.Sin(v[2] * 0.05 + time));
                nv[2] = v[2];

                GL.Vertex3(nv);
            }
            GL.End( );

            GL.Disable(EnableCap.Texture2D);
        }
Beispiel #16
0
        public bool AddChild(object child)
        {
            var domNode = child.As <DomNode>();

            if (domNode != null && IsDerivedFrom(domNode, Schema.vegetationSpawnConfigType.Type))
            {
                SetChild(Schema.terrainType.VegetationSpawnChild, domNode);
                return(true);
            }

            if (domNode != null && IsDerivedFrom(domNode, Schema.abstractTerrainMaterialDescType.Type))
            {
                if (BaseTexture == null)
                {
                    BaseTexture = new DomNode(Schema.terrainBaseTextureType.Type);
                }
                BaseTexture.GetChildList(Schema.terrainBaseTextureType.materialChild).Add(domNode);
                return(true);
            }

            return(false);
        }
Beispiel #17
0
        /// <summary>
        /// Mod_LoadBrushModel
        /// </summary>
        private void LoadBrush(BrushModelData mod, Byte[] buffer)
        {
            mod.Load(mod.Name, buffer, (tx) =>
            {
                if (tx.name != null && tx.name.StartsWith("sky"))    // !Q_strncmp(mt->name,"sky",3))
                {
                    Host.RenderContext.WarpableTextures.InitSky(tx);
                }
                else
                {
                    tx.texture = BaseTexture.FromBuffer(Host.Video.Device, tx.name, new ByteArraySegment(tx.pixels),
                                                        ( Int32 )tx.width, ( Int32 )tx.height, true, true);
                }
            }, (textureFile) =>
            {
                return(Host.Wads.LoadTexture(textureFile));
            });

            //
            // set up the submodels (FIXME: this is confusing)
            //
            for (var i = 0; i < mod.NumSubModels; i++)
            {
                mod.SetupSubModel(ref mod.SubModels[i]);

                if (i < mod.NumSubModels - 1)
                {
                    // duplicate the basic information
                    var name = "*" + (i + 1).ToString( );
                    CurrentModel = FindName(name, ModelType.Brush);
                    CurrentModel.CopyFrom(mod);           // *loadmodel = *mod;
                    CurrentModel.Name = name;             //strcpy (loadmodel->name, name);
                    mod = ( BrushModelData )CurrentModel; //mod = loadmodel;
                }
            }
        }
Beispiel #18
0
 public virtual void DrawTexture2D(BaseTexture texture, int x, int y, Color?colour = null, bool hasAlpha = false)
 {
     this.DrawTexture2D(texture, x, y, texture.Desc.Width, texture.Desc.Height, colour, hasAlpha);
 }
Beispiel #19
0
 public virtual void DrawSpriteModel(BaseTexture texture, mspriteframe_t frame, Vector3 up, Vector3 right, Vector3 origin)
 {
     throw new NotImplementedException( );
 }
Beispiel #20
0
 public virtual void DrawTransTranslate(BaseTexture texture, int x, int y, int width, int height, byte[] translation)
 {
     throw new NotImplementedException( );
 }
Beispiel #21
0
 /// <summary>
 /// Saves a texture to a stream.
 /// </summary>
 /// <param name="texture">The texture.</param>
 /// <param name="format">The format.</param>
 /// <returns>A <see cref="DataStream"/> containing the saved texture.</returns>
 /// <unmanaged>HRESULT D3DXSaveTextureToFileInMemory([Out] ID3DXBuffer** ppDestBuf,[In] D3DXIMAGE_FILEFORMAT DestFormat,[In] IDirect3DBaseTexture9* pSrcTexture,[In, Buffer] const PALETTEENTRY* pSrcPalette)</unmanaged>
 public static DataStream ToStream(BaseTexture texture, ImageFileFormat format)
 {
     return new DataStream(D3DX9.SaveTextureToFileInMemory(format, texture, null ));            
 }
Beispiel #22
0
 /// <summary>
 /// Saves a texture to a stream.
 /// </summary>
 /// <param name="texture">The texture.</param>
 /// <param name="format">The format.</param>
 /// <param name="palette">The palette.</param>
 /// <returns>A <see cref="DataStream"/> containing the saved texture.</returns>
 /// <unmanaged>HRESULT D3DXSaveTextureToFileInMemory([Out] ID3DXBuffer** ppDestBuf,[In] D3DXIMAGE_FILEFORMAT DestFormat,[In] IDirect3DBaseTexture9* pSrcTexture,[In, Buffer] const PALETTEENTRY* pSrcPalette)</unmanaged>
 public static DataStream ToStream(BaseTexture texture, ImageFileFormat format, PaletteEntry[] palette)
 {
     return(new DataStream(D3DX9.SaveTextureToFileInMemory(format, texture, palette)));
 }
 public static int SetTexture(this Parameter param, BaseTexture tex)
 {
     return NativeMethods.cgD3D9SetTexture(param.Handle, tex.ComPointer);
 }
Beispiel #24
0
 public virtual void DrawTexture2D(BaseTexture texture, RectangleF sourceRect, Rectangle destRect, Color?colour = null, bool hasAlpha = false)
 {
     throw new NotImplementedException( );
 }
Beispiel #25
0
 /// <summary>
 /// Saves a texture to a file.
 /// </summary>
 /// <param name="texture">The texture.</param>
 /// <param name="fileName">Name of the file.</param>
 /// <param name="format">The format.</param>
 /// <param name="palette">The palette.</param>
 /// <returns>A <see cref="SharpDX.Result" /> object describing the result of the operation.</returns>
 /// <unmanaged>HRESULT D3DXSaveTextureToFileW([In] const wchar_t* pDestFile,[In] D3DXIMAGE_FILEFORMAT DestFormat,[In] IDirect3DBaseTexture9* pSrcTexture,[In, Buffer] const PALETTEENTRY* pSrcPalette)</unmanaged>
 public static void ToFile(BaseTexture texture, string fileName, ImageFileFormat format, PaletteEntry[] palette)
 {
     D3DX9.SaveTextureToFileW(fileName, format, texture, palette);
 }
Beispiel #26
0
        private int DrawIndexedPrimitiveHook(IntPtr devicePtr, PrimitiveType primitiveType, int baseVertexIndex, int minimumVertexIndex, int numVertices, int startIndex, int primCount)
        {
            Device device = (Device)devicePtr;

            VertexBuffer streamData;
            int          Offset = 0;
            int          Stride = 0;

            device.GetStreamSource(0, out streamData, out Offset, out Stride);
            streamData.Dispose();
            if (Startlog)
            {
                if (Stride == iStride)
                {
                    baseTexture = device.GetTexture(0);
                    found       = false;
                    for (int i = 0; i < baseTextures.Count; i++)
                    {
                        if (baseTextures[i].NativePointer == baseTexture.NativePointer)
                        {
                            found = true;
                        }
                    }

                    if (found == false)
                    {
                        baseTextures.Add(baseTexture);
                    }

                    if (baseTextures[iBaseTex].NativePointer == baseTexture.NativePointer)
                    {
                        bTex = baseTexture.LevelOfDetails;
                        baseVertexIndexFound = baseVertexIndex;
                        minVertexIndexFound  = minimumVertexIndex;
                        numVerticesFound     = numVertices;
                        startIndexFound      = startIndex;
                        primCountFound       = primCount;
                        device.SetRenderState(SharpDX.Direct3D9.RenderState.FillMode, SharpDX.Direct3D9.FillMode.Solid);

                        if (redTexture == null)
                        {
                            redTexture = SharpDX.Direct3D9.Texture.FromMemory(device, red);
                        }

                        device.SetTexture(0, redTexture);
                        device.SetRenderState(SharpDX.Direct3D9.RenderState.ZEnable, false);
                        device.DrawIndexedPrimitive(primitiveType, baseVertexIndex, minimumVertexIndex, numVertices, startIndex, primCount);
                        device.SetRenderState(SharpDX.Direct3D9.RenderState.ZEnable, true);
                        found = false;

                        foreach (DXLogger item in stride)
                        {
                            if (item.Base == baseVertexIndex && item.Min == minimumVertexIndex && item.Num == numVertices && item.Start == startIndex && item.Prim == primCount)
                            {
                                found = true; break;
                            }
                        }

                        if (found == false)
                        {
                            strideLog.Base  = baseVertexIndex;
                            strideLog.Min   = minimumVertexIndex;
                            strideLog.Num   = numVertices;
                            strideLog.Start = startIndex;
                            strideLog.Prim  = primCount;
                            stride.Add(strideLog);
                        }
                    }
                }
            }
            device.DrawIndexedPrimitive(primitiveType, baseVertexIndex, minimumVertexIndex, numVertices, startIndex, primCount);
            return(Result.Ok.Code);
        }
 public void SetTexture(int sampler, BaseTexture texture)
 {
     #if DEBUG_STATE_MANAGER
     var s = device.GetTexture(sampler);
     if (textures[sampler] != s)
         throw new Exception("State inconsistent, " + textures[sampler] + " != " + s);
     #endif
     if (textures[sampler] != texture)
     {
         device.SetTexture(sampler, texture);
         textures[sampler] = texture;
     }
 }
Beispiel #28
0
 /// <summary>
 /// Saves a texture to a file.
 /// </summary>
 /// <param name="texture">The texture.</param>
 /// <param name="fileName">Name of the file.</param>
 /// <param name="format">The format.</param>
 /// <param name="palette">The palette.</param>
 /// <returns>A <see cref="SharpDX.Result" /> object describing the result of the operation.</returns>
 /// <unmanaged>HRESULT D3DXSaveTextureToFileW([In] const wchar_t* pDestFile,[In] D3DXIMAGE_FILEFORMAT DestFormat,[In] IDirect3DBaseTexture9* pSrcTexture,[In, Buffer] const PALETTEENTRY* pSrcPalette)</unmanaged>
 public static void ToFile(BaseTexture texture, string fileName, ImageFileFormat format, PaletteEntry[] palette)
 {
     D3DX9.SaveTextureToFileW(fileName, format, texture, palette);            
 }
 public Sole()
 {
     model = new Model("MEDIA//Sfera5.x", 0);
     EffectPool pool = new EffectPool();
     effect = Effect.FromFile(LogiX_Engine.Device, "MEDIA//Sun.fx", null, ShaderFlags.None, pool);
     effectHandles = new EffectHandle[5];
     effectHandles[0] = effect.GetTechnique("t0");
     effectHandles[1] = effect.GetParameter(null, "matViewProjection");
     effectHandles[2] = effect.GetParameter(null, "Time");
     effectHandles[3] = effect.GetParameter(null, "Texture");
     effectHandles[4] = effect.GetParameter(null, "TexDimension");
     baseTexture = TextureLoader.FromFile(LogiX_Engine.Device, "MEDIA//N030.jpg");
     Alone = new XMaterial(Color.White, Color.White, Color.Black, 1);
     light = new DirectionalLight(VertexData.Empty, Color.FromArgb(60, 10, 0), Color.FromArgb(255, 170, 100), Color.FromArgb(250, 250, 250));
 }
Beispiel #30
0
 public virtual void DrawTexture2D(BaseTexture texture, int x, int y, int width, int height, Color?colour = null, bool hasAlpha = false)
 {
     this.DrawTexture2D(texture, new(x, y, width, height), colour, hasAlpha);
 }
Beispiel #31
0
 public virtual void DrawTexture2D(BaseTexture texture, RectangleF sourceRect, int x, int y, Color?colour = null, bool hasAlpha = false)
 {
     this.DrawTexture2D(texture, sourceRect, new(x, y, texture.Desc.Width, texture.Desc.Height), colour, hasAlpha);
 }
Beispiel #32
0
 /// <summary>
 /// Saves a texture to a file.
 /// </summary>
 /// <param name="texture">The texture.</param>
 /// <param name="fileName">Name of the file.</param>
 /// <param name="format">The format.</param>
 /// <returns>
 /// A <see cref="SharpDX.Result"/> object describing the result of the operation.
 /// </returns>
 /// <unmanaged>HRESULT D3DXSaveTextureToFileW([In] const wchar_t* pDestFile,[In] D3DXIMAGE_FILEFORMAT DestFormat,[In] IDirect3DBaseTexture9* pSrcTexture,[In, Buffer] const PALETTEENTRY* pSrcPalette)</unmanaged>
 public static void ToFile(BaseTexture texture, string fileName, ImageFileFormat format)
 {
     D3DX9.SaveTextureToFileW(fileName, format, texture, null);
 }
Beispiel #33
0
        public override void Render(DrawArgs drawArgs)
        {
            if (!this.isOn)
            {
                return;
            }

            if (!this.isInitialized)
            {
                this.Initialize(drawArgs);
            }

            this.m_pointSprites.Clear();

            int       closestIconDistanceSquared = int.MaxValue;
            PointIcon closestIcon = null;

            // build list of all points in view
            foreach (PointIcon point in this.m_points.Values)
            {
                try
                {
                    // don't bother to do anything else if we aren't even in view
                    if (drawArgs.WorldCamera.ViewFrustum.ContainsPoint(point.Position))
                    {
                        Vector3 translationVector = new Vector3(
                            (float)(point.PositionD.X - drawArgs.WorldCamera.ReferenceCenter.X),
                            (float)(point.PositionD.Y - drawArgs.WorldCamera.ReferenceCenter.Y),
                            (float)(point.PositionD.Z - drawArgs.WorldCamera.ReferenceCenter.Z));

                        Vector3 projectedPoint = drawArgs.WorldCamera.Project(translationVector);

                        // check if inside bounding box of icon
                        int dx = DrawArgs.LastMousePosition.X - (int)projectedPoint.X;
                        int dy = DrawArgs.LastMousePosition.Y - (int)projectedPoint.Y;
                        if (this.SelectionRectangle.Contains(dx, dy))
                        {
                            // Mouse is over, check whether this icon is closest
                            int distanceSquared = dx * dx + dy * dy;
                            if (distanceSquared < closestIconDistanceSquared)
                            {
                                closestIconDistanceSquared = distanceSquared;
                                closestIcon = point;
                            }
                        }

                        PointSpriteVertex pv = new PointSpriteVertex(translationVector.X, translationVector.Y, translationVector.Z, point.Size, point.Color.ToArgb());
                        this.m_pointSprites.Add(pv);
                    }
                }
                catch
                {
                }
                finally
                {
                }
            }

            // render point sprites if any in the list
            try
            {
                if (this.m_pointSprites.Count > 0)
                {
                    // save device state
                    BaseTexture  origTexture           = drawArgs.device.GetTexture(0);
                    VertexFormat origVertexFormat      = drawArgs.device.VertexFormat;
                    float        origPointScaleA       = drawArgs.device.GetRenderState <float>(RenderState.PointScaleA);
                    float        origPointScaleB       = drawArgs.device.GetRenderState <float>(RenderState.PointScaleB);
                    float        origPointScaleC       = drawArgs.device.GetRenderState <float>(RenderState.PointScaleC);
                    bool         origPointSpriteEnable = drawArgs.device.GetRenderState <bool>(RenderState.PointSpriteEnable);
                    bool         origPointScaleEnable  = drawArgs.device.GetRenderState <bool>(RenderState.PointScaleEnable);
                    Blend        origSourceBlend       = drawArgs.device.GetRenderState <Blend>(RenderState.SourceBlend);
                    Blend        origDestBlend         = drawArgs.device.GetRenderState <Blend>(RenderState.DestinationBlend);

                    // set device to do point sprites
                    drawArgs.device.SetTexture(0, this.m_pointTexture.Texture);
                    drawArgs.device.VertexFormat = VertexFormat.Position | VertexFormat.PointSize | VertexFormat.Diffuse;
                    drawArgs.device.SetRenderState(RenderState.PointScaleA, 1f);
                    drawArgs.device.SetRenderState(RenderState.PointScaleB, 0f);
                    drawArgs.device.SetRenderState(RenderState.PointScaleC, 0f);
                    drawArgs.device.SetRenderState(RenderState.PointSpriteEnable, true);
                    drawArgs.device.SetRenderState(RenderState.PointScaleEnable, true);

                    drawArgs.device.SetTextureStageState(0, TextureStage.ColorOperation, (int)TextureOperation.Modulate);
                    drawArgs.device.SetTextureStageState(0, TextureStage.ColorArg1, (int)TextureArgument.Texture);
                    drawArgs.device.SetTextureStageState(0, TextureStage.ColorArg2, (int)TextureArgument.Diffuse);

                    // Draw all visible points
                    drawArgs.device.DrawUserPrimitives(PrimitiveType.PointList, this.m_pointSprites.Count, this.m_pointSprites.ToArray());

                    // Draw label and description of mouseover point
                    if (closestIcon != null)
                    {
                    }

                    // restore device state
                    drawArgs.device.SetTexture(0, origTexture);
                    drawArgs.device.VertexFormat = origVertexFormat;
                    drawArgs.device.SetRenderState(RenderState.PointScaleA, origPointScaleA);
                    drawArgs.device.SetRenderState(RenderState.PointScaleB, origPointScaleB);
                    drawArgs.device.SetRenderState(RenderState.PointScaleC, origPointScaleC);
                    drawArgs.device.SetRenderState(RenderState.PointSpriteEnable, origPointSpriteEnable);
                    drawArgs.device.SetRenderState(RenderState.PointScaleEnable, origPointScaleEnable);
                    drawArgs.device.SetRenderState(RenderState.SourceBlend, origSourceBlend);
                    drawArgs.device.SetRenderState(RenderState.DestinationBlend, origDestBlend);
                }
            }
            catch
            {
            }
        }
Beispiel #34
0
        /// <summary>
        /// Set up a new texture AND a normal map texture (either or both can be null)
        /// </summary>
        /// <param name="t"></param>
        public static void SetTexture(BaseTexture tex, Texture bump)
        {
            effect.SetValue(baseTexture, tex);
            effect.SetValue(isTextured, (tex != null) ? true : false);

            effect.SetValue(bumpTexture, bump);
            effect.SetValue(isBump, (bump != null) ? true : false);
        }
 public static void SetTextureParameter(this Parameter param, BaseTexture tex)
 {
     NativeMethods.cgD3D9SetTextureParameter(param.Handle, tex.ComPointer);
 }
Beispiel #36
0
 public virtual void DrawWaterPolyMultiTexture(byte[] lightMapData, BaseTexture texture, BaseTexture lightMapTexture, int lightMapTextureNumber, GLPoly p, double time)
 {
     throw new NotImplementedException( );
 }
Beispiel #37
0
 /// <summary>
 /// Saves a texture to a file.
 /// </summary>
 /// <param name="texture">The texture.</param>
 /// <param name="fileName">Name of the file.</param>
 /// <param name="format">The format.</param>
 /// <returns>
 /// A <see cref="SharpDX.Result"/> object describing the result of the operation.
 /// </returns>
 /// <unmanaged>HRESULT D3DXSaveTextureToFileW([In] const wchar_t* pDestFile,[In] D3DXIMAGE_FILEFORMAT DestFormat,[In] IDirect3DBaseTexture9* pSrcTexture,[In, Buffer] const PALETTEENTRY* pSrcPalette)</unmanaged>
 public static void ToFile(BaseTexture texture, string fileName, ImageFileFormat format)
 {
     D3DX9.SaveTextureToFileW(fileName, format, texture, null);
 }
 public void SetTexture(int sampler, BaseTexture texture)
 {
     device.SetTexture(sampler, texture);
 }
Beispiel #39
0
 /// <summary>
 /// Saves a texture to a stream.
 /// </summary>
 /// <param name="texture">The texture.</param>
 /// <param name="format">The format.</param>
 /// <returns>A <see cref="DataStream"/> containing the saved texture.</returns>
 /// <unmanaged>HRESULT D3DXSaveTextureToFileInMemory([Out] ID3DXBuffer** ppDestBuf,[In] D3DXIMAGE_FILEFORMAT DestFormat,[In] IDirect3DBaseTexture9* pSrcTexture,[In, Buffer] const PALETTEENTRY* pSrcPalette)</unmanaged>
 public static DataStream ToStream(BaseTexture texture, ImageFileFormat format)
 {
     return(new DataStream(D3DX9.SaveTextureToFileInMemory(format, texture, null)));
 }
Beispiel #40
0
 /// <summary>
 /// Saves a texture to a stream.
 /// </summary>
 /// <param name="texture">The texture.</param>
 /// <param name="format">The format.</param>
 /// <param name="palette">The palette.</param>
 /// <returns>A <see cref="DataStream"/> containing the saved texture.</returns>
 /// <unmanaged>HRESULT D3DXSaveTextureToFileInMemory([Out] ID3DXBuffer** ppDestBuf,[In] D3DXIMAGE_FILEFORMAT DestFormat,[In] IDirect3DBaseTexture9* pSrcTexture,[In, Buffer] const PALETTEENTRY* pSrcPalette)</unmanaged>
 public static DataStream ToStream(BaseTexture texture, ImageFileFormat format, PaletteEntry[] palette)
 {
     return new DataStream(D3DX9.SaveTextureToFileInMemory(format, texture, palette));
 }
 protected void copyFromBaseTexture(BaseTexture baseTexture)
 {
     copyFromImageModifer(baseTexture);
     _method = baseTexture._method;
     _hasNormalMap = baseTexture._hasNormalMap;
 }
Beispiel #42
0
 public void SetValue( string name, BaseTexture val )
 {
     effect.SetValue( GetHandle( name ), val );
 }