Hi Everybody,
I have been working with OpenglES over Windows CE 5 and Visual Studio 2008 and I have not had any kind of problem doing a textured rectangle but when I try to use the same code in VS2013 for Windows EC2013 an error comes out in IImagingFactory (which is in Texture.cs).
I leave part of the code that I am using in case someone has any help. I also leave the Texture.cs file that I am using and where the error comes out
Regards,
Fede
public void CreateBtn()
{
Btn_Texturado btnZommIn = new Btn_Texturado(this, "Imagenes.icono.png",
new Point(0, 50), new Size(100, 100));
}
class Btn_Texturado
{
public Btn_Texturado(Form parent, string s, Point location, Size size)
{
this.parent = parent;
bPushed = false;
Image1 = imagen1;
boton1 = OnDeviceReset(Image1);
Location = location;
Size = size;
}
public Texture OnDeviceReset(string s)
{
// Load our textures
Assembly asm = Assembly.GetExecutingAssembly();
Texture _texture = Texture.LoadStream(asm.GetManifestResourceStream(s), true);
// Bind to the texture we want to render with
gl.BindTexture(gl.GL_TEXTURE_2D, _texture.Name);
return _texture;
}
}
Texture.cs
using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Collections.Generic;
using System.Text;
using OpenGLES;
using System.Reflection;
using System.IO;
using System.Runtime.InteropServices;
namespace OpenGLES
{
public struct BitmapLoadData
{
internal IBitmapImage Bitmap;
internal BitmapImageData Data;
public int Width;
public int Height;
internal bool IsTransparent;
}
public class Texture : IDisposable
{
private Texture()
{
}
uint myName;
public byte[] byteArray;
public uint Name
{
get { return myName; }
}
int myWidth;
public int Width
{
get { return myWidth; }
}
int myHeight;
public int Height
{
get { return myHeight; }
}
bool myIsTransparent = false;
public bool IsTransparent
{
get
{
return myIsTransparent;
}
}
public static int GetValidTextureDimensionFromSize(int size)
{
int shiftAmount = 0;
int minDim = size;
while ((minDim >> 1) >= 1)
{
shiftAmount++;
minDim >>= 1;
}
minDim <<= shiftAmount;
if (minDim < size)
minDim <<= 1;
return minDim;
}
static IImagingFactory myImagingFactory;
unsafe public static BitmapLoadData BeginLoadBitmap(Stream bitmapStream, bool isTransparent)
{
// .NET CF does NOT support transparent images. Need to use the COM IImageFactory to create images with alpha.
if (myImagingFactory == null)
myImagingFactory = (IImagingFactory)Activator.CreateInstance(Type.GetTypeFromCLSID(new Guid("327ABDA8-072B-11D3-9D7B-0000F81EF32E")));
int bytesLength;
byte[] bytes;
MemoryStream memStream = bitmapStream as MemoryStream;
if (memStream != null)
{
bytesLength = (int)memStream.Length;
bytes = memStream.GetBuffer();
}
else
{
bytesLength = (int)bitmapStream.Length;
bytes = new byte[bytesLength];
bitmapStream.Read(bytes, 0, bytesLength);
}
IImage image;
ImageInfo info;
uint hresult = myImagingFactory.CreateImageFromBuffer(bytes, (uint)bytesLength, BufferDisposalFlag.BufferDisposalFlagNone, out image);
image.GetImageInfo(out info);
int resizedWidth = (int)info.Width;
int resizedHeight = (int)info.Height;
resizedWidth = Texture.GetValidTextureDimensionFromSize(resizedWidth);
resizedHeight = Texture.GetValidTextureDimensionFromSize(resizedHeight);
int resizedDim = Math.Max(resizedWidth, resizedHeight);
if (resizedDim == (int)info.Width && resizedDim == (int)info.Height)
{
resizedWidth = 0;
resizedHeight = 0;
}
else
{
resizedWidth = resizedDim;
resizedHeight = resizedDim;
}
IBitmapImage bitmap;
myImagingFactory.CreateBitmapFromImage(image, (uint)resizedWidth, (uint)resizedHeight, PixelFormatID.PixelFormatDontCare, InterpolationHint.InterpolationHintDefault, out bitmap);
Marshal.FinalReleaseComObject(image);
Size size;
bitmap.GetSize(out size);
RECT rect = new RECT(0, 0, size.Width, size.Height);
BitmapImageData data;
if (isTransparent)
{
bitmap.LockBits(ref rect, ImageLockMode.ImageLockModeWrite | ImageLockMode.ImageLockModeRead, PixelFormatID.PixelFormat32bppARGB, out data);
for (int y = 0; y < data.Height; y++)
{
for (int x = 0; x < data.Stride; x += 4)
{
byte* bp = (byte*)data.Scan0 + data.Stride * y + x;
byte temp = bp[0];
bp[0] = bp[2];
bp[2] = temp;
}
}
}
else
{
bitmap.LockBits(ref rect, ImageLockMode.ImageLockModeRead, PixelFormatID.PixelFormat16bppRGB565, out data);
}
BitmapLoadData ret = new BitmapLoadData();
ret.Data = data;
ret.Bitmap = bitmap;
ret.Width = (int)info.Width;
ret.Height = (int)info.Height;
ret.IsTransparent = isTransparent;
return ret;
}
unsafe public static Texture LoadBitmap(BitmapLoadData loadData)
{
IBitmapImage bitmap = loadData.Bitmap;
bool isTransparent = loadData.IsTransparent;
Size size;
bitmap.GetSize(out size);
RECT rect = new RECT(0, 0, size.Width, size.Height);
uint glFormat = gl.GL_RGB;
uint glType = gl.GL_UNSIGNED_SHORT_5_6_5;
if (isTransparent)
{
glFormat = gl.GL_RGBA;
glType = gl.GL_UNSIGNED_BYTE;
}
Texture ret = new Texture();
uint tex;
gl.GenTextures(1, &tex);
ret.myName = tex;
gl.BindTexture(gl.GL_TEXTURE_2D, ret.myName);
gl.TexImage2D(gl.GL_TEXTURE_2D, 0, glFormat, size.Width, size.Height, 0, glFormat, glType, loadData.Data.Scan0);
gl.TexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR);
gl.TexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR);
ret.myWidth = loadData.Width;
ret.myHeight = size.Height;
ret.myIsTransparent = isTransparent;
return ret;
}
public static void EndLoadBitmap(BitmapLoadData loadData)
{
loadData.Bitmap.UnlockBits(ref loadData.Data);
Marshal.FinalReleaseComObject(loadData.Bitmap);
}
public static Texture LoadStream(Stream bitmapStream, bool isTransparent)
{
BitmapLoadData loadData = BeginLoadBitmap(bitmapStream, isTransparent);
Texture ret = LoadBitmap(loadData);
EndLoadBitmap(loadData);
return ret;
}
#region IDisposable Members
unsafe public void Dispose()
{
uint name = myName;
gl.DeleteTextures(1, &name);
}
#endregion
}
}