public void LoadTGA() { string file = "test.tga"; IntPtr surfacePtr = VideoSetup(); IntPtr imagePtr = SdlImage.IMG_LoadTGA_RW(Sdl.SDL_RWFromFile(file, "rb")); Assert.IsFalse(imagePtr == IntPtr.Zero); Sdl.SDL_Rect rect1 = new Sdl.SDL_Rect(0, 0, 200, 200); Sdl.SDL_Rect rect2 = new Sdl.SDL_Rect(0, 0, 200, 200); int result = Sdl.SDL_BlitSurface(imagePtr, ref rect1, surfacePtr, ref rect2); Sdl.SDL_UpdateRect(surfacePtr, 0, 0, 200, 200); Thread.Sleep(sleepTime); Assert.AreEqual(result, 0); this.Quit(); }
protected override void OnKeyUp(KeyEventArgs e) { if (!_LockKeyboardInput) { try { if (!designMode) { Sdl.Event evt = GetKeyEvent((SDLK.Key)Enum.Parse(typeof(SDLK.Key), e.KeyCode.ToString()), (SDLK.ModifierKeys)e.Modifiers, false); Sdl.PushEvent(out evt); } } catch { } } base.OnKeyUp(e); }
/// <summary> /// /// </summary> private IntPtr VideoSetup() { Sdl.SDL_Quit(); init = Sdl.SDL_Init(Sdl.SDL_INIT_VIDEO); IntPtr surfacePtr; //Assert.IsNotNull(surfacePtr); //Sdl.SDL_FreeSurface(surfacePtr); surfacePtr = Sdl.SDL_SetVideoMode( width, height, bpp, flags); Assert.IsNotNull(surfacePtr); return(surfacePtr); }
public bool IsKeyPressed(int key) { bool pressed = false; Sdl.SDL_PumpEvents(); Sdl.SDL_Event evt; Sdl.SDL_PollEvent(out evt); int numKeys; byte[] keys = Sdl.SDL_GetKeyState(out numKeys); if (keys[key] == 1) { pressed = true; } return(pressed); }
public int KeyPressed() { int pressed = -1; Sdl.SDL_PumpEvents(); Sdl.SDL_Event keyEvent; if (Sdl.SDL_PollEvent(out keyEvent) == 1) { if (keyEvent.type == Sdl.SDL_KEYDOWN) { pressed = keyEvent.key.keysym.sym; } } return(pressed); }
public void zoomSurface() { this.InitSdl(); Sdl.SDL_Rect rect1 = new Sdl.SDL_Rect(0, 0, 400, 400); Sdl.SDL_Rect rect2 = new Sdl.SDL_Rect(0, 0, 400, 400); IntPtr bmpImagePtr = Sdl.SDL_LoadBMP("test.bmp"); IntPtr zoomSurfacePtr = SdlGfx.zoomSurface(bmpImagePtr, 5, 2, SdlGfx.SMOOTHING_OFF); int result = Sdl.SDL_BlitSurface(zoomSurfacePtr, ref rect1, surfacePtr, ref rect2); Assert.IsNotNull(zoomSurfacePtr); Assert.IsFalse(zoomSurfacePtr == IntPtr.Zero); Sdl.SDL_UpdateRect(surfacePtr, 0, 0, 400, 400); //int results = Sdl.SDL_Flip(surfacePtr); Thread.Sleep(sleepTime); }
/// <summary> /// Initialize timer. /// </summary> public static bool Initialize() { if ((Sdl.SDL_WasInit(Sdl.SDL_INIT_TIMER)) == (int)SdlFlag.FalseValue) { if (Sdl.SDL_Init(Sdl.SDL_INIT_TIMER) != (int)SdlFlag.Success) { throw SdlException.Generate(); } return(false); } else { return(true); } }
public static bool KeyPressed(int c) { bool pressed = false; Sdl.SDL_PumpEvents(); Sdl.SDL_Event myEvent; Sdl.SDL_PollEvent(out myEvent); int numkeys; byte[] keys = Tao.Sdl.Sdl.SDL_GetKeyState(out numkeys); if (keys[c] == 1) { pressed = true; } return(pressed); }
public static void WriteHiddenText(string txt, short x, short y, byte r, byte g, byte b, Font f) { Sdl.SDL_Color color = new Sdl.SDL_Color(r, g, b); IntPtr textoComoImagen = SdlTtf.TTF_RenderText_Solid( f.GetPointer(), txt, color); //if (textoComoImagen == IntPtr.Zero) // Environment.Exit(5); Sdl.SDL_Rect origen = new Sdl.SDL_Rect(0, 0, width, height); Sdl.SDL_Rect dest = new Sdl.SDL_Rect(x, y, width, height); Sdl.SDL_BlitSurface(textoComoImagen, ref origen, hiddenScreen, ref dest); }
/// <summary> /// Returns an array of events in the event queue. /// </summary> /// <param name="eventMask">Mask for event that will be removed from queue</param> /// <param name="numberOfEvents">Number of events to remove</param> public static void Remove(EventMask eventMask, int numberOfEvents) { Sdl.SDL_Event[] events = new Sdl.SDL_Event[numberOfEvents]; Sdl.SDL_PumpEvents(); int result = Sdl.SDL_PeepEvents( events, events.Length, Sdl.SDL_GETEVENT, (int)eventMask); if (result == (int)SdlFlag.Error) { throw SdlException.Generate(); } }
/** JoyPulsado: devuelve TRUE si * ha sido pulsado un botón del jostick * (cualquiera, por ahora) */ public static bool JoystickPulsado(int boton) { if (!existeJoystick) { return(false); } if (Sdl.SDL_JoystickGetButton(joystick, boton) > 0) { return(true); } else { return(false); } }
// Joystick methods /** JoystickPressed: returns TRUE if * a certain button in the joystick/gamepad * has been pressed */ public static bool JoystickPressed(int boton) { if (!isThereJoystick) { return(false); } if (Sdl.SDL_JoystickGetButton(joystick, boton) > 0) { return(true); } else { return(false); } }
public static KeyboardState GetState() { state = new KeyboardState((int)Sdl.SDLK_LAST); int numKeys = 0; byte[] keys = Sdl.SDL_GetKeyState(out numKeys); for (int key = Sdl.SDLK_UNKNOWN; key < Sdl.SDLK_LAST; key++) { if (keys[key] > 0) { state[keyDictionary[key]] = KeyState.Down; } } return(state); }
public override void EndScreenDeviceChange(string screenDeviceName, int clientWidth, int clientHeight) { this.screenDeviceName = screenDeviceName; OnScreenDeviceNameChanged(); int flags = Sdl.SDL_OPENGL; if (willBeFullScreen) { flags |= Sdl.SDL_FULLSCREEN; } int bitsPerPixel = 0; SurfaceFormat format; if (game.GraphicsDevice == null) { // TODO This cast should be tested against MS XNA GraphicsDeviceManager graphicsManager = (GraphicsDeviceManager)game.Services.GetService(typeof(IGraphicsDeviceManager)); format = graphicsManager.PreferredBackBufferFormat; } else { format = game.GraphicsDevice.PresentationParameters.BackBufferFormat; } if (format == SurfaceFormat.Color || format == SurfaceFormat.Bgr32 || format == SurfaceFormat.Rgba32) { bitsPerPixel = 32; } // TODO add support for other surface formats IntPtr sdlSurfacePtr = Sdl.SDL_SetVideoMode(clientWidth, clientHeight, bitsPerPixel, flags); if (sdlSurfacePtr != IntPtr.Zero) { sdlSurface = (Sdl.SDL_Surface)Marshal.PtrToStructure(sdlSurfacePtr, typeof(Sdl.SDL_Surface)); } #warning SDL 1.2 doesn't support getting the window position, only the dimensions clientBounds.Width = clientWidth; clientBounds.Height = clientHeight; OnClientSizeChanged(); inTransition = false; }
private void setSDLVideo() { /* To center a non-fullscreen window we need to set an environment * variable */ Sdl.SDL_putenv("SDL_VIDEO_CENTERED=center"); /* the video info structure contains the current video mode. Prior to * calling setVideoMode, it contains the best available mode * for your system. Post setting the video mode, it contains * whatever values you set the video mode with. * First we point at the SDL structure, then test to see that the * point is right. Then we copy the data from the structure to * the safer vidInfo variable. */ /* according to the SDL documentaion, the flags parameter passed to setVideoMode * affects only the 2D SDL surface, not the openGL. To set their properties * use the syntax below. We enable vsync because we are running the loop * unfettered and we don't want the loop redrawing the buffer * while it is being written to screen */ Sdl.SDL_GL_SetAttribute(Sdl.SDL_GL_SWAP_CONTROL, 1); //enable vsync Sdl.SDL_GL_SetAttribute(Sdl.SDL_GL_RED_SIZE, 8); Sdl.SDL_GL_SetAttribute(Sdl.SDL_GL_GREEN_SIZE, 8); Sdl.SDL_GL_SetAttribute(Sdl.SDL_GL_BLUE_SIZE, 8); Sdl.SDL_GL_SetAttribute(Sdl.SDL_GL_DEPTH_SIZE, 16); Sdl.SDL_GL_SetAttribute(Sdl.SDL_GL_MULTISAMPLEBUFFERS, 1); Sdl.SDL_GL_SetAttribute(Sdl.SDL_GL_MULTISAMPLESAMPLES, 2); Sdl.SDL_GL_SetAttribute(Sdl.SDL_GL_DOUBLEBUFFER, 1); /* the setVideoMode function returns the current frame buffer as an * SDL_Surface. Again, we grab a pointer to it, then place its * content into the non pointery surface variable. I say 'non-pointery', * but this SDL variable must have a pointer in it because it can * access the current pixels in the framebuffer. */ var ptr = Sdl.SDL_SetVideoMode(w, h, bpp, flags); if (ptr == IntPtr.Zero) { Console.WriteLine("Error qsetting the video mode"); Sdl.SDL_Quit(); } InitGL(); ReSizeGLScene(w, h); }
internal static void AddDevice(int deviceId) { var gamepad = new GamePadInfo(); gamepad.Device = Sdl.GameController.Open(deviceId); gamepad.HapticDevice = Sdl.Haptic.OpenFromJoystick(Sdl.GameController.GetJoystick(gamepad.Device)); var id = 0; while (Gamepads.ContainsKey(id)) { id++; } Gamepads.Add(id, gamepad); if (gamepad.HapticDevice == IntPtr.Zero) { return; } try { if (Sdl.Haptic.EffectSupported(gamepad.HapticDevice, ref _hapticLeftRightEffect) == 1) { Sdl.Haptic.NewEffect(gamepad.HapticDevice, ref _hapticLeftRightEffect); gamepad.HapticType = 1; } else if (Sdl.Haptic.RumbleSupported(gamepad.HapticDevice) == 1) { Sdl.Haptic.RumbleInit(gamepad.HapticDevice); gamepad.HapticType = 2; } else { Sdl.Haptic.Close(gamepad.HapticDevice); } } catch { Sdl.Haptic.Close(gamepad.HapticDevice); gamepad.HapticDevice = IntPtr.Zero; Sdl.ClearError(); } RefreshTranslationTable(); }
public void GetVideoInfo() { IntPtr videoInfoPtr = Sdl.SDL_GetVideoInfo(); Assert.IsNotNull(videoInfoPtr); Sdl.SDL_VideoInfo videoInfo = (Sdl.SDL_VideoInfo) Marshal.PtrToStructure(videoInfoPtr, typeof(Sdl.SDL_VideoInfo)); Console.WriteLine(videoInfo.hw_available); Console.WriteLine(videoInfo.wm_available); Console.WriteLine(videoInfo.video_mem); Console.WriteLine(videoInfo.current_h); Console.WriteLine(videoInfo.current_w); Sdl.SDL_FreeSurface(videoInfoPtr); }
static IntPtr veraSmall; //The pointer to the font #endregion static void Draw() { Sdl.SDL_FillRect(screen, ref screenArea, 0); //Clear for next draw cycle screenData = (Sdl.SDL_Surface)Marshal.PtrToStructure(screen, typeof(Sdl.SDL_Surface)); //Put the screen data in its place switch (Adventurer.gameState) { case GameState.OpeningMenu: Draw_Opening(); break; case GameState.NameSelect: Draw_Name(); break; case GameState.CreatureSelect: Draw_CreatureSel(); break; case GameState.HelpMenu: Draw_Help(); break; case GameState.MainGame: Draw_Main(); break; case GameState.InventoryMenu: Draw_Inventory(); break; case GameState.HealthMenu: Draw_Health(); break; case GameState.WaitForPosition: Draw_GetPos(); break; case GameState.EscapeMenu: Draw_Escape(); break; } Sdl.SDL_Flip(screen); //Update screen } //Draws things to the screen
protected virtual void Dispose(bool disposing) { if (_disposed) { return; } Sdl.Window.Destroy(_handle); _handle = IntPtr.Zero; if (_icon != IntPtr.Zero) { Sdl.FreeSurface(_icon); } _disposed = true; }
/// <summary> /// Create a Font from a byte array in memory. /// </summary> /// <param name="array">A array of byte that should be the font data</param> /// <param name="pointSize">Size of font</param> public Font(byte[] array, int pointSize) { if (array == null) { throw new ArgumentNullException("array"); } if (!Font.IsFontSystemInitialized) { Font.InitializeFontSystem(); } this.Handle = SdlTtf.TTF_OpenFontRW(Sdl.SDL_RWFromMem(array, array.Length), 0, pointSize); if (this.Handle == IntPtr.Zero) { throw FontException.Generate(); } }
/// <summary> /// Returns the number of seconds before the audio track starts on the cd. /// </summary> /// <remarks></remarks> /// <param name="trackNumber">Track to query</param> public int TrackStart(int trackNumber) { int result = Sdl.CD_INDRIVE((int)this.Status); GC.KeepAlive(this); if (result == 1) { Sdl.SDL_CD cd = (Sdl.SDL_CD)Marshal.PtrToStructure( this.Handle, typeof(Sdl.SDL_CD)); return((int)Timer.FramesToSeconds(cd.track[trackNumber].offset)); } else { return(0); } }
public void Update(double elapsedTime) { _countDown -= elapsedTime; if (Sdl.SDL_NumJoysticks() > 0) { if (_countDown <= 0 || _input.Controller.ButtonA.Pressed) { Finish(); } } if (_countDown <= 0 || _input.Keyboard.IsKeyPressed(System.Windows.Forms.Keys.Enter)) { Finish(); } }
public SdlGameWindow(Game game) { _game = game; _screenDeviceName = ""; Instance = this; _winx = Sdl.Window.PosUndefined; _winy = Sdl.Window.PosUndefined; _width = GraphicsDeviceManager.DefaultBackBufferWidth; _height = GraphicsDeviceManager.DefaultBackBufferHeight; if (Sdl.Patch >= 4) { var display = GetMouseDisplay(); _winx = display.X + display.Width / 2; _winy = display.Y + display.Height / 2; } Sdl.SetHint("SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS", "0"); Sdl.SetHint("SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS", "1"); using ( var stream = Assembly.GetEntryAssembly().GetManifestResourceStream(Assembly.GetEntryAssembly().EntryPoint.DeclaringType.Namespace + ".Icon.bmp") ?? Assembly.GetEntryAssembly().GetManifestResourceStream("Icon.bmp") ?? Assembly.GetExecutingAssembly().GetManifestResourceStream("MonoGame.bmp")) { if (stream != null) { using (var br = new BinaryReader(stream)) { try { var src = Sdl.RwFromMem(br.ReadBytes((int)stream.Length), (int)stream.Length); _icon = Sdl.LoadBMP_RW(src, 1); } catch { } } } } _handle = Sdl.Window.Create("", _winx, _winy, GraphicsDeviceManager.DefaultBackBufferWidth, GraphicsDeviceManager.DefaultBackBufferHeight, Sdl.Window.State.Hidden); }
public void WriteText(string text, short x, short y, Font fontType) { byte r = 0, g = 255, b = 0; Sdl.SDL_Color color = new Sdl.SDL_Color(r, g, b); IntPtr textAsImage = SdlTtf.TTF_RenderText_Solid(fontType.GetFontType(), text, color); if (textAsImage == IntPtr.Zero) { Environment.Exit(5); } Sdl.SDL_Rect src = new Sdl.SDL_Rect(0, 0, screenWidth, screenHeight); Sdl.SDL_Rect dest = new Sdl.SDL_Rect(x, y, screenWidth, screenHeight); Sdl.SDL_BlitSurface(textAsImage, ref src, screen, ref dest); }
public void EnsureHost() { int result = Sdl.SDL_Init(Sdl.SDL_INIT_TIMER | Sdl.SDL_INIT_VIDEO | Sdl.SDL_INIT_JOYSTICK); if (result == 0) { System.Diagnostics.Debug.WriteLine("SDL initialized"); } else { System.Diagnostics.Debug.WriteLine("Couldn't initialize SDL"); } Il.ilInit(); window = new SdlGameWindow(game); }
public App() { //SDL is comprised of 8 subsystems. Here we initialize the video if (Sdl.SDL_Init(Sdl.SDL_INIT_VIDEO) < 0) { Console.WriteLine("Error initializing SDL"); Sdl.SDL_Quit(); return; } /* Rather than set the video properties up in the constructor, I set * them in setVideo. The reason for this is that 2 pointers are used * to interact with SDL structures. Once used they convert their * handles into vidInfo and surface tamer variables. That this * occurs inside the function means the pointers will release * their memory on function exit. */ setSDLVideo(); /* openGL is not part of SDL, rather it runs in a window handled * by SDL. here we set up some openGL state */ //initialize game game = new GameClass(); /* finP is the property get/setter for the boolean fin in the game * class. It is held in the game class because the game class handles * events. When escape is pressed, fin is set to true and the following * loop * terminates. * The function tick is called every loop. It is passed the time * taken for each loop */ while (!game.finP) { game.pollEvents(); Tick(); //updates the game object Sdl.SDL_Delay(1); //release the thread } /* When the loop ends the code drops down to here. SDL_Quit shuts * down the SDL subsystems initialized by SDL_Init */ Sdl.SDL_Quit(); return; }
/** JoystickMoved: returns TRUE if * the joystick/gamepad has been moved * up to the limit in any direction * Then, int returns the corresponding * X (1=right, -1=left) * and Y (1=down, -1=up) */ public static bool JoystickMoved(out int posX, out int posY) { posX = 0; posY = 0; if (!isThereJoystick) { return(false); } posX = Sdl.SDL_JoystickGetAxis(joystick, 0); // Leo valores (hasta 32768) posY = Sdl.SDL_JoystickGetAxis(joystick, 1); // Normalizo valores if (posX == -32768) { posX = -1; // Normalizo, a -1, +1 o 0 } else if (posX == 32767) { posX = 1; } else { posX = 0; } if (posY == -32768) { posY = -1; } else if (posY == 32767) { posY = 1; } else { posY = 0; } if ((posX != 0) || (posY != 0)) { return(true); } else { return(false); } }
public static void Init(short w, short h, int colors, bool fullScreen) { width = w; height = h; int flags = Sdl.SDL_HWSURFACE | Sdl.SDL_DOUBLEBUF | Sdl.SDL_ANYFORMAT; if (fullScreen) { flags |= Sdl.SDL_FULLSCREEN; } Sdl.SDL_Init(Sdl.SDL_INIT_EVERYTHING); hiddenScreen = Sdl.SDL_SetVideoMode( width, height, colors, flags); Sdl.SDL_Rect rect2 = new Sdl.SDL_Rect(0, 0, (short)width, (short)height); Sdl.SDL_SetClipRect(hiddenScreen, ref rect2); SdlTtf.TTF_Init(); // Joystick initialization isThereJoystick = true; if (Sdl.SDL_NumJoysticks() < 1) { isThereJoystick = false; } if (isThereJoystick) { joystick = Sdl.SDL_JoystickOpen(0); if (joystick == IntPtr.Zero) { isThereJoystick = false; } } // Time lapse between two consecutive mouse clicks, // so that they are not too near mouseClickLapse = 10; lastMouseClick = Sdl.SDL_GetTicks(); }
public void Tick() { TimeSpan elapsedUpdateTime = TimeSpan.FromMilliseconds(Sdl.SDL_GetTicks() - gameUpdateTime.TotalRealTime.TotalMilliseconds); if (isFixedTimeStep) { while (elapsedUpdateTime < TargetElapsedTime) { #warning To low resolution with ms (10^-3) Thread.Sleep(TargetElapsedTime.Milliseconds - elapsedUpdateTime.Milliseconds); elapsedUpdateTime = TimeSpan.FromMilliseconds(Sdl.SDL_GetTicks() - gameUpdateTime.TotalRealTime.TotalMilliseconds); } gameUpdateTime.ElapsedGameTime = TargetElapsedTime; gameUpdateTime.TotalGameTime = gameUpdateTime.TotalGameTime.Add(TargetElapsedTime); } else { gameUpdateTime.ElapsedGameTime = elapsedUpdateTime; gameUpdateTime.TotalGameTime = gameUpdateTime.TotalGameTime.Add(elapsedUpdateTime); } gameUpdateTime.ElapsedRealTime = elapsedUpdateTime; gameUpdateTime.TotalRealTime = gameUpdateTime.TotalRealTime.Add(elapsedUpdateTime); Update(gameUpdateTime); elapsedUpdateTime = TimeSpan.FromMilliseconds(Sdl.SDL_GetTicks() - gameUpdateTime.TotalRealTime.TotalMilliseconds); if (isFixedTimeStep && elapsedUpdateTime > TargetElapsedTime) { gameUpdateTime.IsRunningSlowly = true; } else { gameUpdateTime.IsRunningSlowly = false; } if (!BeginDraw()) { return; } Draw(gameUpdateTime); EndDraw(); }
/** JoystickMoved: returns TRUE if * the joystick/gamepad has been moved * up to the limit in any direction * Then, int returns the corresponding * X (1=right, -1=left) * and Y (1=down, -1=up) */ public static bool JoystickMoved(out int posX, out int posY) { posX = 0; posY = 0; if (!isThereJoystick) { return(false); } posX = Sdl.SDL_JoystickGetAxis(joystick, 0); posY = Sdl.SDL_JoystickGetAxis(joystick, 1); if (posX == -32768) { posX = -1; } else if (posX == 32767) { posX = 1; } else { posX = 0; } if (posY == -32768) { posY = -1; } else if (posY == 32767) { posY = 1; } else { posY = 0; } if ((posX != 0) || (posY != 0)) { return(true); } else { return(false); } }
public void InitializeSettings(Sdl.Core.Settings.ISettingsBundle settingsBundle, string configurationId) { //loading of filter settings }