• Announcements

    • khawk

      Download the Game Design and Indie Game Marketing Freebook   07/19/17

      GameDev.net and CRC Press have teamed up to bring a free ebook of content curated from top titles published by CRC Press. The freebook, Practices of Game Design & Indie Game Marketing, includes chapters from The Art of Game Design: A Book of Lenses, A Practical Guide to Indie Game Marketing, and An Architectural Approach to Level Design. The GameDev.net FreeBook is relevant to game designers, developers, and those interested in learning more about the challenges in game development. We know game development can be a tough discipline and business, so we picked several chapters from CRC Press titles that we thought would be of interest to you, the GameDev.net audience, in your journey to design, develop, and market your next game. The free ebook is available through CRC Press by clicking here. The Curated Books The Art of Game Design: A Book of Lenses, Second Edition, by Jesse Schell Presents 100+ sets of questions, or different lenses, for viewing a game’s design, encompassing diverse fields such as psychology, architecture, music, film, software engineering, theme park design, mathematics, anthropology, and more. Written by one of the world's top game designers, this book describes the deepest and most fundamental principles of game design, demonstrating how tactics used in board, card, and athletic games also work in video games. It provides practical instruction on creating world-class games that will be played again and again. View it here. A Practical Guide to Indie Game Marketing, by Joel Dreskin Marketing is an essential but too frequently overlooked or minimized component of the release plan for indie games. A Practical Guide to Indie Game Marketing provides you with the tools needed to build visibility and sell your indie games. With special focus on those developers with small budgets and limited staff and resources, this book is packed with tangible recommendations and techniques that you can put to use immediately. As a seasoned professional of the indie game arena, author Joel Dreskin gives you insight into practical, real-world experiences of marketing numerous successful games and also provides stories of the failures. View it here. An Architectural Approach to Level Design This is one of the first books to integrate architectural and spatial design theory with the field of level design. The book presents architectural techniques and theories for level designers to use in their own work. It connects architecture and level design in different ways that address the practical elements of how designers construct space and the experiential elements of how and why humans interact with this space. Throughout the text, readers learn skills for spatial layout, evoking emotion through gamespaces, and creating better levels through architectural theory. View it here. Learn more and download the ebook by clicking here. Did you know? GameDev.net and CRC Press also recently teamed up to bring GDNet+ Members up to a 20% discount on all CRC Press books. Learn more about this and other benefits here.

Gorax

Members
  • Content count

    641
  • Joined

  • Last visited

Community Reputation

202 Neutral

About Gorax

  • Rank
    Advanced Member
  1. A 1500x1500 RGB image will only take up about 6.5MB of memory, even when it's uncompressed, and mipmaps wouldn't add enough to that to get anywhere near the 800MB you mention. Check to make sure you're not reloading the textures (or the terrain segments) every frame.
  2. The only thing I can think of is the fact that you're using glutSolidCube(). Do you know if it sets the third texture coordinate?
  3. OpenGL

    If you just want the page to flip over, stiff and unnaturally, you can just change two of the vertices at some specific rate so the quad flips from one side to the other. If you take this path, you'll need to ensure you flip the page based upon some rate of time, and not a number of frames, because the performance of Android devices varies. If you want it the page to have a slight curve in it, you'll need more vertices, and you'll probably be better off creating an animated model for it rather than trying to hard code it.
  4. OpenGL

    This really should be in the Your Announcements forum. Just out of curiosity though, do you plan on changing the Open GL tutorials to reflect somewhat more modern approaches to rendering things? Sure it's nice to start off easy, but I'm not entirely sure it's the best way to go about things these days...
  5. Quote:Original post by Juanxo perhaps with glBufferSubData or glBufferData? I'm going to have to agree with this approach. I've never been able to get the (un)map functions to work quite right (probably my fault more than anything), but the buffer functions work well. Textures get updated the exact same way, so I'm not entirely sure why they have the (un)map functions. Seems like overkill to me.
  6. OpenGL

    If you want to write your own, but don't want to go through the effort of learning how everything works, the Open GL Reference Pages actually show you how all of the matrix functions work.
  7. Depending on how the data is transmitted, you can use CreateFile() to open the device, and then read and write to it like a normal file. You'll need to ensure you read and write specific data lengths as specified in the device's capabilities, which can be found using the HidP_GetCaps() function (the input, output and feature report lengths), otherwise the read and write functions will fail. I've used those functions to play around with my Wiimotes which operate over Bluetooth, and it seems to work quite well.
  8. They seem to work fine in Google Chrome. I can't say the same for IE (I'm using XP too). I'm not entirely sure why the canvas element's being used at all, especially given the fact that you have been able to do stuff like this for years now using Java. Seems a little redundant to me...
  9. OpenGL

    I doubt that loading the identity matrix is what you want. Since you're using the built-in matrices, you can just use glPushMatrix() and glPopMatrix() before applying translations and rotations to objects. If you plan on moving to newer versions of Open GL, you'll need to deal with the matrices yourself, but it's important to get the concepts worked out first, otherwise you'll find it's like jumping into the deep end.
  10. You can enable depth testing, and use a depth value (assuming you're working with the standard horizontal X axis, and vertical Y axis, Z would be the depth). Alternatively, you can set the depth writing to less than or equal, and sort all of the sprites before you render them. It requires a little more work, but if you plan on using Open GL for more complex rendering jobs, this type of knowledge will help further down the line.
  11. OpenGL

    OpenCV gives you rectangles that tell you where the faces are. The videos show multiple points of detection (the eyes, nose and mouth), which are used to calculate the direction of the head. What does the Lucas Kanade method give you as a result? Without knowing that, I cannot tell you how you should be rendering the cylinder.
  12. OpenGL

    Google works great for stuff like this: http://www.opengl.org/registry/specs/ARB/texture_compression.txt. Quote: Compressed texture images can be obtained from the GL in uncompressed form by calling GetTexImage and in compressed form by calling GetCompressedTexImageARB. Queried compressed images can be saved and later reused by calling CompressedTexImage[123]DARB. Pre-compressed texture images do not need to be processed by the GL and should significantly improve texture loading performance relative to uncompressed images. The only thing I can't guarantee is if the compression formats will be supported. I do know that other vendors usually allow for things like this, but I'm not sure if it should always be relied upon... You could always have a copy of both the compressed and uncompressed images, and load the compressed images if the given setup allows for it, and fall back to the uncompressed ones if it doesn't.
  13. OpenGL

    If you've already got code that works, you only need to copy and paste it in the appropriate order, and in this case, it's almost exactly like I just said. Here's the basics of how it should work, but you will need to copy and paste the necessary code, or write your own to fill the necessary parts in: //you will need to set the video frame up yourself, //it's here as a reference only void* videoFrame; bool run = true; bool lucasKanadeEnabled = false; int faceDetectionRectangle[2][2]; while (run){ //--> INSERT CODE TO CAPTURE VIDEO FRAME HERE <-- //If you can detect the faces if (!lucasKanadeEnabled){ //FUNCTION USED TO DETECT FACES USING OPENCV HERE: if (detectFacesUsingOpenCV(videoFrame,faceDetectionRectangle)){ lucasKanadeEnabled = true; } } bool renderedCylinder = false; //If a face has been detected by OpenCV either now, or previously if (lucasKanadeEnabled){ //FUNCTION USED TO DETECT THE FACES AS NECESSARY USING THE //LUCAS KANADE METHOD - ALSO USED TO RENDER THE CYLINDER AS NEEDED if (detectFacesUsingLucasKanade(videoFrame,faceDetectionRectangle)){ renderedCylinder = true; }else{ lucasKanadeEnabled = false; } } if (!renderedCylinder){ renderImageWithoutCylinder(videoFrame); } }
  14. Most people use their own source management, keeping music playing all the time, and dropping sounds only when the number of sounds playing is greater than or equal to the current number of sources. You could do something similar, and add a priority to the sounds and cut some off as necessary.
  15. OpenGL

    Assuming I understand that correctly, you have this: Program #1: - Detects faces using Open CV. - Face tracking is done on a single image. - Renders the cylinder over the face correctly. Program #2: - Detects faces using Lucas-Kanade's optical flow method, but only in a region selected by the user. - Face tracking is done on a video stream. - Doesn't have the cylinder rendered. If so, you need to do this: - Capture a video frame. - Use OpenCV to find the face. - Use the rectangle from the detected face as the rectangle used for your Lucas-Kanade method. - Render the cylinder as needed. - Keep using the Lucas-Kanade method until it fails to find the face. - Use OpenCV to find the face again. Is that what you are trying to do?