• Advertisement

Search the Community

Showing results for tags 'Optimization'.



More search options

  • Search By Tags

    Type tags separated by commas.
  • Search By Author

Content Type


Categories

  • Audio
    • Music and Sound FX
  • Business
    • Business and Law
    • Career Development
    • Production and Management
  • Game Design
    • Game Design and Theory
    • Writing for Games
    • UX for Games
  • Industry
    • Interviews
    • Event Coverage
  • Programming
    • Artificial Intelligence
    • General and Gameplay Programming
    • Graphics and GPU Programming
    • Engines and Middleware
    • Math and Physics
    • Networking and Multiplayer
  • Visual Arts
  • Archive

Categories

  • News

Categories

  • Audio
  • Visual Arts
  • Programming
  • Writing

Categories

  • GameDev Unboxed

Categories

  • Game Dev Loadout

Categories

  • Game Developers Conference
    • GDC 2017
    • GDC 2018
  • Power-Up Digital Games Conference
    • PDGC I: Words of Wisdom
    • PDGC II: The Devs Strike Back
    • PDGC III: Syntax Error

Forums

  • Audio
    • Music and Sound FX
  • Business
    • Games Career Development
    • Production and Management
    • Games Business and Law
  • Game Design
    • Game Design and Theory
    • Writing for Games
  • Programming
    • Artificial Intelligence
    • Engines and Middleware
    • General and Gameplay Programming
    • Graphics and GPU Programming
    • Math and Physics
    • Networking and Multiplayer
  • Visual Arts
    • 2D and 3D Art
    • Critique and Feedback
  • Topical
    • Virtual and Augmented Reality
    • News
  • Community
    • For Beginners
    • GameDev Challenges
    • GDNet+ Member Forum
    • GDNet Lounge
    • GDNet Comments, Suggestions, and Ideas
    • Coding Horrors
    • Your Announcements
    • Hobby Project Classifieds
    • Indie Showcase
    • Article Writing
  • Affiliates
    • NeHe Productions
    • AngelCode
  • Workshops
    • C# Workshop
    • CPP Workshop
    • Freehand Drawing Workshop
    • Hands-On Interactive Game Development
    • SICP Workshop
    • XNA 4.0 Workshop
  • Archive
    • Topical
    • Affiliates
    • Contests
    • Technical
  • GameDev Challenges's Topics

Calendars

  • Community Calendar
  • Games Industry Events
  • Game Jams
  • GameDev Challenges's Schedule

Blogs

There are no results to display.

There are no results to display.

Developers

Developers


Group


About Me


Website


Industry Role


Twitter


Github


Twitch


Steam

Found 46 results

  1. Hi Forum, in terms of rendering a tiled game level, lets say the level is 3840x2208 pixels using 16x16 tiles. which method is recommended; method 1- draw the whole level, store it in a texture-object, and only render whats in view, each frame. method 2- on each frame, loop trough all tiles, and only draw and render it to the window if its in view. are both of these methods valid? is there other ways? i know method 1 is memory intensive but method 2 is processing heavy. thanks in advance
  2. circle drawing method comparison

    Hello, I am trying to make a GeometryUtil class that has methods to draw point,line ,polygon etc. I am trying to make a method to draw circle. There are many ways to draw a circle. I have found two ways, The one way: public static void drawBresenhamCircle(PolygonSpriteBatch batch, int centerX, int centerY, int radius, ColorRGBA color) { int x = 0, y = radius; int d = 3 - 2 * radius; while (y >= x) { drawBresenhamCircle(batch, centerX, centerY, x, y, color); if (d <= 0) { d = d + 4 * x + 6; } else { y--; d = d + 4 * (x - y) + 10; } x++; //drawBresenhamCircle(batch,centerX,centerY,x,y,color); } } private static void drawBresenhamCircle(PolygonSpriteBatch batch, int centerX, int centerY, int x, int y, ColorRGBA color) { drawPoint(batch, centerX + x, centerY + y, color); drawPoint(batch, centerX - x, centerY + y, color); drawPoint(batch, centerX + x, centerY - y, color); drawPoint(batch, centerX - x, centerY - y, color); drawPoint(batch, centerX + y, centerY + x, color); drawPoint(batch, centerX - y, centerY + x, color); drawPoint(batch, centerX + y, centerY - x, color); drawPoint(batch, centerX - y, centerY - x, color); } The other way: public static void drawCircle(PolygonSpriteBatch target, Vector2 center, float radius, int lineWidth, int segments, int tintColorR, int tintColorG, int tintColorB, int tintColorA) { Vector2[] vertices = new Vector2[segments]; double increment = Math.PI * 2.0 / segments; double theta = 0.0; for (int i = 0; i < segments; i++) { vertices[i] = new Vector2((float) Math.cos(theta) * radius + center.x, (float) Math.sin(theta) * radius + center.y); theta += increment; } drawPolygon(target, vertices, lineWidth, segments, tintColorR, tintColorG, tintColorB, tintColorA); } In the render loop: polygonSpriteBatch.begin(); Bitmap.drawBresenhamCircle(polygonSpriteBatch,500,300,200,ColorRGBA.Blue); Bitmap.drawCircle(polygonSpriteBatch,new Vector2(500,300),200,5,50,255,0,0,255); polygonSpriteBatch.end(); I am trying to choose one of them. So I thought that I should go with the one that does not involve heavy calculations and is efficient and faster. It is said that the use of floating point numbers , trigonometric operations etc. slows down things a bit. What do you think would be the best method to use? When I compared the code by observing the time taken by the flow from start of the method to the end, it shows that the second one is faster. (I think I am doing something wrong here ). Please help! Thank you.
  3. Hi there. I am really sorry to post this, but I would like to clarify the delta compression method. I've read Quake 3 Networking Model: http://trac.bookofhook.com/bookofhook/trac.cgi/wiki/Quake3Networking, but still have some question. First of all, I am using LiteNetLib as networking library, it works pretty well with Google.Protobuf serialization. But then I've faced with an issue when the server pushes a lot of data, let's say 10 players, and server pushes 250kb/s of data with 30hz tickrate, so I realized that I have to compress it, let's say with delta compression. As I understood, the client and server both use unreliable channel. LiteNetLib meta file says that unreliable packet can be dropped, or duplicated; while sequenced channel says that packet can be dropped but never duplicated, so I think I have to use the sequenced channel for Delta compression? And do I have to use reliable channel for acknowledgment, or I can just go with sequenced, and send the StateId with a snapshot and not separately? Thank you.
  4. Welcome back colony managers, here comes a set of awesome new features improving your space colonization systems. This month we spent a lot of time into pimping the user interface of the game into it's 4th evolution and making it 4k ready by the way. With the remediation center a very important infrastructure building made it into this release and also the logistic center got a workover enabling you to fully automate repairing and cleaning processes. And there's more... TL;DR New user interface Remediation center & carbon sequestration Logistic center is now maintenance station Desertification threat and temple power Solar park and wind farm alignement Mountain variations Fixes & improvements New User Interface The existing user interface clearly did not meet the demands of our colony & planet simulation. It was very clumsy and reminiscent of a casual mobile phone game. So we rebuilt it, using the smaller and much clearer Roboto font for all text elements, while keeping our futuristic fonts for headers and elements that need highlighting. The new interface now has become much easier to read while taking less screen space and thisway giving even more focus to the planet itself. [gallery columns="2" ids="6249,6248,6254,6255"] If you are using a relatively small screen with a high resolution you can still zoom the interface up to 150% in the options. A side effect of our work is that the new user interface has a higher resolution and thus is ready for your 4K display. Remediation Center & Carbon Sequestration The new building remediation center comes with an additional worker drone and uses this drone to automatically start the clean up process for nearby fields. An powerful upgrade for the center is carbon sequestration - the technical separation and storage of CO2 emissions from surrounding buildings and power plants. Thanks to underground compression, the exhaust gases do not enter the atmosphere. The second ugrade for this building is "Advanced Remediation Process" it halves the cost of soil clean up in the area. Logistic Center is now Maintenance Station The logistic center is now called "Maintenance station" and automatically repairs nearby damaged buildings by default. It's upgrades are the fire station and "Advanced Repair Process", which halves the cost of repair processes in the area. Desertification Threat and Temple Power In the course of global warming there will be new deserts emerging next to others. Thereby the infertile wasteland is growing. The only way to prevent this is to plant forests onto desert fields so it can't spread. Trees will effectively stop the process of desertification. In the illuminati temple you can use gaian energy to create a field of desert anywhere around the world. Except on fields with forests on them. Solar Panels and Wind Farms They are aligning to the sun and the wind direction now. Mountain Variations Each mountain has two versions now to bring more variety into the game's look. These two versions are now put to the three edges of big mountains as well to make it easier to see whether a field is blocked by mountains. Fixes & Improvements Fixed animation problems: we had some seriously strange problems with sub models and animations. Mystery finally concluded! Ships and oilplatforms no longer visible under water, while being built. City expansion now also needs drones. Show diplomatic relation progress as ring (full ring reaches next diplomatic level) Fixed orientation angle of volcanoes and huge mountains on small planets Sandbox category for mushroom forests As always we wish you a good fun and hope you let us know if anything comes to your mind about the new features! Jens & Martin
  5. Hello! As far as I understand, the traditional approach to the architecture of a game with different states or "screens" (such as a menu screen, a screen where you fly your ship in space, another screen where you walk around on the surface of a planet etc.) is to make some sort of FSM with virtual update/render methods in the state classes, which in turn are called in the game loop; something similar to this: struct State { virtual void update()=0; virtual void render()=0; virtual ~State() {} }; struct MenuState:State { void update() override { /*...*/ } void render() override { /*...*/ } }; struct FreeSpaceState:State { void update() override { /*...*/ } void render() override { /*...*/ } }; struct PlanetSurfaceState:State { void update() override { /*...*/ } void render() override { /*...*/ } }; MenuState menu; FreeSpaceState freespace; PlanetSurfaceState planet; State * states[] = {&menu, &freespace, &planet}; int currentState = 0; void loop() { while (!exiting) { /* Handle input, time etc. here */ states[currentState]->update(); states[currentState]->render(); } } int main() { loop(); } My problem here is that if the state changes only rarely, like every couple of minutes, then the very same update/render method will be called several times for that time period, about 100 times per second in case of a 100FPS game. This seems a bit to make dynamic dispatch, which has some performance penalty, pointless. Of course, one may argue that a couple hundred virtual function calls per second is nothing for even a not so modern computer, and especially nothing compared to the complexity of the render/update function in a real life scenario. But I am not quite sure. Anyway, I might have become a bit too paranoid about virtual functions, so I wanted to somehow "move out" the virtual function calls from the game loop, so that the only time a virtual function is called is when the game enters a new state. This is what I had in mind: template<class TState> void loop(TState * state) { while (!exiting && !stateChanged) { /* Handle input, time etc. here */ state->update(); state->render(); } } struct State { /* No update or render function declared here! */ virtual void run()=0; virtual ~State() {} }; struct MenuState:State { void update() { /*...*/ } void render() { /*...*/ } void run() override { loop<MenuState>(this); } }; struct FreeSpaceState:State { void update() { /*...*/ } void render() { /*...*/ } void run() override { loop<FreeSpaceState>(this); } }; struct PlanetSurfaceState:State { void update() { /*...*/ } void render() { /*...*/ } void run() override { loop<PlanetSurfaceState>(this); } }; MenuState menu; FreeSpaceState freespace; PlanetSurfaceState planet; State * states[] = {&menu, &freespace, &planet}; void run() { while (!exiting) { stateChanged = false; states[currentState]->run(); /* Runs until next state change */ } } int main() { run(); } The game loop is basically the same as the one before, except that it now exits in case of a state change as well, and the containing loop() function has become a function template. Instead of loop() being called directly by main(), it is now called by the run() method of the concrete state subclasses, each instantiating the function template with the appropriate type. The loop runs until the state changes, in which case the run() method shall be called again for the new state. This is the task of the global run() function, called by main(). There are two negative consequences. First, it has become slightly more complicated and harder to maintain than the one above; but only SLIGHTLY, as far as I can tell based on this simple example. Second, code for the game loop will be duplicated for each concrete state; but it should not be a big problem as a game loop in a real game should not be much more complicated than in this example. My question: Is this a good idea at all? Does anybody else do anything like this, either in a scenario like this, or for completely different purposes? Any feedback is appreciated!
  6. Hello, I want to optimize the used memory in my game so that it supports low end devices - for instance iPhone 4s. I know that some of the main things I should look into are memory leaks, big textures and some game specific things, which occupy a lot of memory. To detect all that I am using MTuner on Windows and Instruments (Allocations) on XCode. What are you generally looking for when optimizing memory? What instruments are you using? My target platform is iOS.
  7. 【DirectX9 Get shader bytecode】 I hook DrawIndexedPrimitive HookCode(PPointer(g_DeviceBaseAddr + $148)^,@NewDrawIndexedPrimitive, @OldDrawIndexedPrimitive); function NewDrawIndexedPrimitive(const Device:IDirect3DDevice9;_Type: TD3DPrimitiveType; BaseVertexIndex: Integer; MinVertexIndex, NumVertices, startIndex, primCount: LongWord): HResult; stdcall; var ppShader: IDirect3DVertexShader9; _Code:Pointer; _CodeLen:Cardinal; begin Device.GetVertexShader(ppShader);//<------1.Get ShaderObject(ppShader) ppShader.GetFunction(nil,_CodeLen); GetMem(_Code,_CodeLen); ppShader.GetFunction(_Code,_CodeLen);//<----2.Get bytecode from ShaderObject(ppShader) Result:=OldDrawIndexedPrimitive(Self,_Type,BaseVertexIndex,MinVertexIndex, NumVertices, startIndex, primCount); end; 【How to DirectX11 Get VSShader bytecode?】 I hook DrawIndexed pDrawIndexed:=PPointer(PUINT_PTR(UINT_PTR(g_ImmContext)+0)^ + 12 * SizeOf(Pointer))^; HookCode(pDrawIndexed,@NewDrawIndexed,@OldDrawIndexed); procedure NewDrawIndexed(g_Real_ImmContext:ID3D11DeviceContext;IndexCount: UINT;StartIndexLocation: UINT;BaseVertexLocation: Integer); stdcall; var game_pVertexShader: ID3D11VertexShader; ppClassInstances: ID3D11ClassInstance; NumClassInstances: UINT begin g_Real_ImmContext.VSGetShader(game_pVertexShader,ppClassInstances,NumClassInstances); //<------1.Get ShaderObject(game_pVertexShader) .....//<----【2.Here's how to get bytecode from ShaderObject(game_pVertexShader)?】 OldDrawIndexed(ImmContext, IndexCount, StartIndexLocation, BaseVertexLocation); end; Another way: HOOK CreateVertexShader() but HOOK need to be created before the game CreateVertexShader, HOOK will not get bytecode if the game is running later,I need to get bytecode at any time like DirectX9
  8. Once I needed a program for packing an atlas with 3d models. I could not find one, so I made it. Now it has only basic functionality. Should I improve it further? Does it need someone else? Link to download(for Windows): https://drive.google.com/open?id=1CLizcUAOsYnbdfyKCYDcGxmso79GPBuv
  9. Which ASO Tools are Right for Your Game? When I started doing app store optimization (ASO) for my games, I was so overwhelmed by the numerous ASO tools available in the market… App Annie, Mobile Action, Meatti, Sensor Tower, App Radar, Priori Data, ASOdesk, Searchman, TheTool, Keyword Tool, AppKeywords.net, Apptentive, Appbot, AppFollow, Apptopia, APPlyzer, SplitMetrics, StoreMaven, Raise Metrics, TestNest, SearchAdsHQ, SearchAds by Mobile Action, adAhead, you name it. And as if things were not already complicated enough … These ASO tools provide very different features, pricing, options, … When deciding which ones to use, I was like… How to Choose your ASO Tools If you are looking for your best ASO tools, check out my findings below. I will first start with a categorization of ASO tools, and follow up with a big list of app store optimization tools. You can then choose your ASO tools based on the category and the details of individual tools. Free Bonus: Click here to get a free comparison spreadsheet of all top ASO tools. It can be printed nicely on one page, and you can easily sort the ASO tools by type, price, availability of free version, etc.It also includes 2 more ASO tools that are not covered in this post. Types of ASO Tools ASO tools come in many flavors and packages, and they can be grouped into the following categories: 1) App Keyword Optimization Tools ASO tools of this type help you optimize your app keywords to increase your app search traffic. The app keyword related features include app keyword suggestions, keyword optimization, keyword tracking, etc. ASO tools like Mobile Action, Sensor Tower, Meatti, App Radar, Priori Data, ASOdesk, Searchman, TheTool, Keyword Tool, and AppKeywords.net are some good examples. 2) Review & Sentiment Analysis Tools ASO tools of this type perform optimization of your user reviews and ratings. Tools like Appbot, Mobile Action, Meatti and TheTool analyze your user ratings and review contents, and tell you what your users like and don’t like. With this kind of sentiment analysis, you can then refine your product development roadmap to earn better ratings. For example, if you find out a lot of users are complaining about a specific issue, you can prioritize your effort to fix that problem, and tell the complaining users about the solution. Many users will appreciate your positive reaction to their comments, and give you better ratings. Related to this, AppFollow provides features that help you reply all comments in App Store and Play Store efficiently. On the other hand, ASO tools like Apptentive help you increase the chance of getting 5-star reviews. It optimizes your app’s rating prompt process by deciding who, when, and how to present your rating prompts. 3) A/B Testing Tools A/B testing enables you to test your mobile app just like a science project. It helps you test two or more app product pages and determine which one gives you a better download conversion rate. Tools like Splitmetrics, Store Maven, TestNest, and RaiseMetrics are some good A/B testing tools for your app product page. 4) Search Ads Optimization Tools These ASO tools help you optimize your advertising campaign on Apple Search Ads. They provide automation features and competitor data that help you run ad campaigns more effectively. Some tools also integrate with app attribution partners (Adjust, AppsFlyer, Kochava, TUNE, etc.) and allows you to optimize campaigns not only for installs, but also for in-app events. ASO tools like SearchAdsHQ, SearchAds by Mobile Action, and adAhead are some good examples. 5) App Store Intelligence Tools ASO tools of this type provide estimates of competitor performance and app market trends. For instance, they offer estimates on data on competitor apps. These estimates include app downloads, revenue, advertising spend trends, market penetrations, etc. The information can be useful to app product managers and marketing managers for doing competitive analysis and marketing planning. App Annie, Mobile Action, Sensor Tower, Priori Data, Apptopia, and APPlyzer are ASO tools that offer app store intelligence. Top ASO Tools Listed below are the top ASO tools in 2018. The list is organized according to the types of ASO tools discussed above. To make the list more authentic, I personally reached out to everyone of them and collect their views of how their tools can help their users. And I’m fortunate enough to receive some great answers! Lastly, I’ve prepared an one-page comparison spreadsheet with all the ASO tools. It is a printable version, and you can easily sort the ASO tools by type, price, availability of free version, etc. 1) App Keyword Optimization Tools Mobile Action Meatti Sensor Tower App Radar Priori Data ASOdesk Searchman TheTool Keyword Tool AppKeywords.net 2) Review & Sentiment Analysis Tools Mobile Action Meatti TheTool Apptentive Appbot AppFollow 3) A/B Testing Tools SplitMetrics StoreMaven Raise Metrics TestNest 4) Search Ads Optimization Tools SearchAdsHQ SearchAds by Mobile Action adAhead 5) App Store Intelligence Tools App Annie Mobile Action Sensor Tower Priori Data Apptopia APPlyzer A Side-by-Side Comparison of ASO Tools One Page Comparison Spreadsheet of all ASO Tools Mobile Data Intelligence & Actionable Insights Mobile Action Mobile Action is an intuitive App Store Optimization tool and a data company providing actionable insights for their users. It provides its users with the most accurate data possible but that’s what every ASO tool claims to do. In fact the difference of Mobile Action is its dedicated customer success team that provides instant support across the entire globe 24/7. Mobile Action got into business as a ASO agency so we know a great deal of stuff regarding App Store Optimization and we build our tools from the perspective of an ASO specialist. Aykut Karaalioglu, CEO Mobile Action ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: $69/Month Boost App Downloads using Artificial Intelligence Meatti Meatti helps mobile app developers boost app downloads without spending a penny on advertising. Our Meatti platform analyzes data from millions of apps every day. Using the data and artificial intelligence, it provides app developers with the best keyword and optimization suggestions to gain more app downloads in a systematic way. Marcus Kay, CEO Meatti ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: $24/Month Data That Drives App Growth Sensor Tower Sensor Tower provides mobile developers with powerful market intelligence and App Store Optimization solutions that enable them to easily surface competitive insights and achieve maximum organic growth on the App Store and Google Play. Randy Nelson, Head of Mobile Insights Sensor Tower ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: $79/Month App Store Optimization made easy App Radar App Radar is an search engine optimization tool that helps app developers optimizing their apps being more visible within the app stores. With a direct integration into iTunes Connect & Google Play Console, App Radar makes the process of App Store Optimization easy like never before. Thomas Kriebernegg, CEO App Radar ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: $150/Month Win Your Mobile Market Priori Data Priori Data App Intelligence enables you to research, benchmark, and track your competition all in one place. Create individual or team viewable watchlists and comparisons of apps in your competitive set, and track their rank, download, revenue, DAU, MAU, ARPDAU and retention performance on a daily basis. Set up smart alerts to get notified of any major shifts, and receive daily and weekly reports so that you never lose track of the big picture. Priori Data ASO Tool - Quick Facts: Free version / trial available? No Premium plan starts at: $99/Month Boost your organic downloads with Data-Driven Marketing Technologies ASOdesk Our dream is to make our customers more and more successful. App Store Optimization is a never-ending optimization process that can bring millions of free installs. Our clients have many opportunities to make their business more effective. Just in a couple of clicks our product is available for you and ready to help you to find new real users. Sergey Sharov, CEO ASOdesk ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: $41.6/Month App Data Solutions to accelerate Ecosystem success Searchman SearchMan is the leading App Analytics Data & Technology company with over 100 000 companies actively using our solutions to help them succeed in the App economy. SearchMan’s parent company, AppGrooves was founded in San Francisco Bay Area by former executives of Rakuten, AdMob, Yahoo and many other startups. Our investors include 500 Startups, Digital Garage, and several internet luminaries whose experience includes Disney, Google, Yahoo, Gree, Ricoh, Hatena, and Rakuten. Searchman ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: $25/Month Performance-Based Mobile App Marketing & ASO tool TheTool TheTool helps developers and marketers to track and optimize their App Store Optimization strategy in 91 countries or globally, carry out keyword research, benchmark ASO KPIs with competitors, understand the impact of marketing actions on installs, conversion rate and revenue; and, ultimately, grow the organic installs of their apps and games. Basically we help people make more money with apps. Daniel Peris, CEO TheTool ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: €29 /Year Find Great Keywords Using Autocomplete Keyword Tool KeywordTool.io helps marketers and app creators discover what app store users are looking for by generating keyword suggestions using the app store’s autocomplete. A simple search can yield hundreds of hidden keywords for you to optimize your app towards. Khai Yong Ng, Head of Growth KeywordTool.io ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: $48 /Year Sneak into Google Play's auto-suggest feature AppKeywords.net When I launched AppKeywords.net back in 2015 it was really hard to get proper data on keywords. Sure you had a lot tools giving you some kind of estimates but you could not be really sure if the data is accurate. Especially when you were researching non-english keywords. Sebastian Knopp, Growth and Product Strategy Appkeyword.net ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: Free Build a brand your customers love Apptentive Using proactive mobile communication tools, Apptentiveempowers companies to better understand more of their customers—at scale—in order to drive app downloads, create seamless customer experiences, and validate product roadmaps. The product gives brands the opportunity to listen to, engage with, and retain their customers through intelligently timed surveys, messages, and prompts. They power millions of customer interactions every month for companies including Buffalo Wild Wings, eBay, Philips, Saks Fifth Avenue, and Zillow. Robi Ganguly, CEO Apptentive ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: Custom Plan App review & ratings analysis for mobile teams Appbot Appbot helps developers understand how customers feel about their apps, by monitoring and analyzing their app reviews and ratings across all major platforms. Appbot applies proprietary sentiment analysis and clustering techniques to help developers understand current issues, and identify quick wins. Claire Mcgregor, Co-founder Appbot ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: $39 /Month Reviews & Updates Monitor for App Store & Google Play AppFollow AppFollow is created to support everyone (this year we will expand this support even further) involved in the process of development and growth of mobile apps and games. We support everyone whether it is a developer, CEO, customer support or product manager, ASO expert or publisher. Anatoly Sharifulin, CEO & Co-founder AppFollow ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: Custom Plan Achieve success through apps App Annie The industry’s first app data platform integrates your app data with our comprehensive market data, cutting-edge data science, deep data foundation and engaging data experience. Through our platform, you can get immediate access to all our latest technology innovations and data sets, share the right data with the right people at the right time, pinpoint prime opportunities — and most crucially — create winning strategies. App Annie ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: $15,000+/Year (source: TechCrunch) Grow Your App Business Apptopia Apptopia provides competitive intelligence for the mobile app economy. Through intuitive tools, we’re able to display actionable data. This means user acquisition managers, product teams, SDK sales teams, growth marketers and more can make smarter decisions faster. Data we provide includes downloads, revenue, usage, retention, rank, SDK data, audience intelligence, advertising intelligence and more. Adam Blacker, Communications Lead and Brand Ambassador Apptopia ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: $55 /Month App Market Analysis & App Store Optimization APPlyzer Applyzer is a leading app industry analysis service providing market insights since 2009. Our service offers reliable data to a wide range of customers in the app business – From actionable data for publishers to relevant information for tech investors. Applyzer ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: €10 /Month Optimize Your App Conversion Rates on the App Store and Google Play with A/B Testing SplitMetrics With SplitMetrics, such app publishers as Rovio, Halfbrick, Wargaming, ZeptoLab, Pocket Gems optimize app store conversions by A/B testing app page elements: from icons and screenshots to subtitles, app previews, etc. To help publishers get the most out of their app marketing efforts, SplitMetrics shares industry benchmarks and a great volume of educational materials, such as an AppGrowthLab course. Alexandra Lamachenka, Head of Marketing SplitMetrics ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: $4,999 /Year Increase app store conversion rates & pay less for every install StoreMaven StoreMaven helps more than 60% of top-grossing app publishers optimize their app store product pages to increase install rates and reduce the cost of user acquisition. Companies like Google, Uber, Facebook and Zynga rely on StoreMaven‘s testing and analytics platform to define their ASO and global mobile marketing strategies. Gad Maor, CEO StoreMaven ASO Tool - Quick Facts: Free version / trial available? No Premium plan starts at: Custom Plan Raise your App Store & Google Play install rates with A/B testing RaiseMetrics Insight Is Everything. RaiseMetrics provides a visual understanding of how your audience interacts with your app page, and what you can do to maximize conversions. RaiseMetrics ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: $99 /Month Best Self-serve App Store and Google Play AB Testing Platform TestNest Best self-serve app store and google play ab testing platform. Unoptimized App Store pages may increase CPIs by up to 40%. A/B test your app listing pages and get more quality users for less. Learn from user behavior analysis make optimized data-driven decisions. TestNest ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: $149 /Month Optimize Apple App Store Ads for Revenue, not just downloads SearchAdsHQ SearchAdsHQ helps app publishers run ROI-driven Apple Search Ads campaigns. To make it possible, the platform connects Apple Search Ads with app attribution partners (Adjust, AppsFlyer, Kochava, TUNE, etc.) and allows to optimize campaigns not only for installs, but for in-app events: in-app purchases, subscriptions, conversions. Alexandra Lamachenka, Head of Marketing SearchAdsHQ ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: Custom Plan Mobile Action provides awesome tools to make the most of your Search Ads and keep up with the competition. SearchAds by Mobile Action Searchads.com was created specifically for Apple Search Ads and as Apple Search Ads is a rather new service it tries to cover the shortcomings of Apple Search Ads by providing competitor data, more reactive notifications and automation features that allows users to get the most out of the time and resources they have spent in Apple Search Ads. Aykut Karaalioglu, CEO SearchAds by Mobile Action ASO Tool - Quick Facts: Free version / trial available? No Premium plan starts at: Custom Plan Optimize Apple App Store Ads for Revenue, not just downloads adAhead adAhead is an Apple Search Ads Optimization Platform that is fully self-managed by mobile app marketers. It provides GEO reports, COHORT analysis, keyword reports and charts, powerful rule manager tool, keyword rank monitoring, custom ad scheduler, bulk edit, duplication option for campaigns/ad groups, and multi account dashboard. adAhead also provides fully featured live demo for new visitors. Yury Listapad, CEO adAhead ASO Tool - Quick Facts: Free version / trial available? Yes Premium plan starts at: 2.5% of ad spend A Side-by-Side Comparison of ASO Tools The list of ASO tools here is really long. To make it easier to do comparison, I've prepared an one-page comparison spreadsheet with all the ASO tools for you. It is a printable version, and you can easily sort the ASO tools by type, price, availability of free version, etc. Click here to get a free comparison spreadsheet of all top ASO tools. The spreadsheet also includes 2 bonus tools and additional details that I didn’t have room to include in this post. This post originally appeared on Meatti Marcus Kay Marcus is the founder of Meatti - a platform that helps mobile game developers boost app downloads using artificial intelligence. Find him on Twitter, LinkedIn and his blog.
  10. More Adventures in Robust Coding

    Hello GameDev, This entry is going to be a big one for me, and it's going to cover a lot. What I plan to cover on my recent development journey is the following: 1 - Goal of this Blog entry. 2 - Lessons learned using Node.js for development and testing as opposed to Chrome console. 3 - Linear Path algorithm for any surface. 4 - Dynamic Path Finding using Nodes for any surface, incorporating user created, dynamic assets. 5 - short term goals for the game. -- - -- - -- - -- - -- - -- - Goal of this Blog entry - -- - -- - -- - -- - -- - -- My goal for this adventure is to create a dynamic path-finding algorithm so that: - any AI that is to be moved will be able to compute the shortest path from any two points on the surface of the globe. - the AI will navigate around bodies of water, vegetation, dynamic user assets such as buildings and walls. - will compute path in less then 250 milliseconds. There are a few restrictions the AI will have to follow, in the image above you can see land masses that are cut off from one another via rivers and bodies of water are uniquely colored. If an AI is on a land mass of one color, for now, it will only be able to move to a location on the same colored land mass. However; there are some land masses that take up around 50% of the globe and have very intricate river systems. So the intended goal is be able to have an AI be on one end of the larger land mass and find the shortest path to the opposite end within 250 milliseconds. Currently my path finding algorithm can find the shortest path in anywhere from 10 ms and up, and when I say up, I mean upwards of 30 seconds, and that's because of the way I built the algorithm, which is in the process of being optimised. -- - -- - -- - -- - -- - -- - Lessons learned using Node.js for development and testing - -- - -- - -- - -- - -- - -- As of this writing I am using Node.js to test the efficiency of my algorithms. This has slowed down my development. I am not a programmer by trade, I've taught myself the bulk-work of what I know, and I often spend my time re-inventing the wheel and learning things the hard way. Last year I made the decision to move my project over to Node.js for continued development, eventually it all had to be ported over to Node.js anyways. In hind sight I would have done things differently. I would have continued to use Chrome console for testing and development, small scale, then after the code was proven to be robust would I then port it over to Node.js. If there is one lesson I'd like to pass on to aspiring and new programmers, it's this, use a language and development environment that allows you, the programmer, to jump into the code while it's running and follow each iteration, line by line, of code as it's be executed, basically debugging. It is so easy to catch errors in logic that way. Right now I'm throwing darts at a dart board, guesses what I should be sending to the console for feedback to help me learn more about logical errors using Node.js, see learning the hard way. -- - -- - -- - -- - -- - -- - Linear Path algorithm for any surface. - -- - -- - -- - -- - -- - -- In the blog entry above I go into detail explaining how I create a world. The important thing to take away from it is that every face of the world has information about all surrounding faces sharing vertices pairs. In addition, all vertices have information regarding those faces that use it for their draw order, and all vertices have information regarding all vertices that are adjacent to them. An example vertices and face object would look like the following: Vertices[ 566 ] = { ID: 566, x: -9.101827364, y: 6.112948791, z: 0.192387718, connectedFaceIDs: [ 90 , 93 , 94 , 1014 , 1015 , 1016 ], // clockwise order adjacentVertices: [ 64 , 65 , 567 , 568 , 299 , 298 ] // clockwise order } Face[ 0 ] = { ID: 0, a: 0, b: 14150, c: 14149, sharedEdgeVertices: [ { a:14150 , b: 14149 } , { a:0 , b: 14150 } , { a:14149 , b:0 } ], // named 'cv' in previous blog post sharedEdgeFaceIDs: [ 1 , 645 , 646 ], // named 's' in previous blog post drawOrder: [ 1 , 0 , 2 ], // named 'l' in previous blog post } Turns out the algorithm is speedy for generating shapes of large sizes. My buddy who is a Solutions Architect told me I'm a one trick pony, HA! Anyways, this algorithm comes in handy because now if I want to identify a linear path along all faces of a surface, marked as a white line in the picture above, you can reduce the number of faces to be tested, during raycasting, to the number of faces the path travels across * 2. To illustrate, imagine taking a triangular pizza slice which is made of two faces, back to back. the tip of the pizza slice is touching the center of the shape you want to find a linear path along, the two outer points of the slice are protruding out from the surface of the shape some distance so as to entirely clear the shape. When I select my starting and ending points for the linear path I also retrieve the face information those points fall on, respectively. Then I raycaste between the sharedEdgeVertices, targeting the pizza slice. If say a hit happens along the sharedEdgeVertices[ 2 ], then I know the next face to test for the subsequent raycaste is face ID 646, I also know that since the pizza slice comes in at sharedEdgeVertice[ 2 ], that is it's most likely going out at sharedEdgeVertices[ 1 ] or [ 0 ]. If not [ 1 ] then I know it's 99% likely going to be [ 0 ] and visa-versa. Being able to identify a linear path along any surface was the subject of my first Adventure in Robust Coding. Of course there are exceptions that need to be accounted for. Such as, when the pizza slice straddles the edge of a face, or when the pizza slice exits a face at a vertices. Sometimes though when I'm dealing with distances along the surface of a given shape where the pizza slice needs to be made up of more than one set of back to back faces, another problem can arise: I learned about the limitations of floating point numbers too, or at least that's what it appear to be to me. I'm sure most of you are familiar with some variation of the infinite chocolate bar puzzle So with floating point numbers I learned that you can have two faces share two vertices along one edge, raycaste at a point that is directly between the edges of two connecting faces, and occasionally, the raycaste will miss hitting either of the two faces. I attribute this in large part because floating point numbers only capture an approximation of a point, not the exact point. Much like in the infinite chocolate bar puzzle there exists a tiny gap along the slice equal in size to the removed piece, like wise, that tiny gap sometimes causes a miss for the raycaste. If someone else understands this better please correct me. -- - -- - -- - -- - -- - -- - Dynamic Path Finding using Nodes for any surface - -- - -- - -- - -- - -- - -- Now that I've got the linear path algorithm working in tip top shape, I use it in conjunction with Nodes to create the pathfinding algorithm. Firstly I identify the locations for all nodes. I do this using a Class I created called Orientation Vector, I mention them in the blog post above. When they're created, they have a position vector, a pointTo vector, and an axis vector. The beauty of this class is that I can merge them, which averages their position, pointTo, and axis vectors, and it allows me to rotate them along any axis, and it allows me to move them any distance along the axis of their pointTo vector. To create shoreline collision geometry, and node collision geometry, illustrated above, and node locations along shorelines, illustrated below, I utilise the Orientation Vector Class. Firstly, the water table for the world is set to an arbitrary value, right now it's 1.08, so if a vector for a given face falls below the table and one or two vertors are above the table then I know the face is a shoreline face. Then I use simple Math to determine at what two points the face meets the water and create two OVectors, each pointing at each-other. Then I rotate them along their y axis 90 and -90 degrees respectively so that they are now facing inland. Since each face, which are shoreline faces, touch one another, there will be duplicate OVectors a each point along the shore. However, each Ovector will have a pointTo vector relative to it's sister Ovector during creation. I merge the paired Ovectors at each point along the shore, this averages their position, pointTo and axis. I then move them inland a small distance. The result is the blue arrows above. The blue arrows are the locations of three of the thousands of nodes created for a given world. Each Node has information about the shoreline collision geometry, the node collision geometry ( the geometry connecting nodes ), and the Node to its left and the Node to its right. Each face of collision geometry is given a Node ID to refer to. So to create the path-finding algorithm. I first identify the linear path between the starting and ending points. I then test each segment of the linear path for collision geometry. If I get a hit, I retrieve the Node ID. This gives me the location for the Node associated for a given face of collision geometry. I then travel left and right along connecting Nodes checking to see if a new Linear path to the end point is possible, if no immediate collision geometry is encountered, the process continues and is repeated as needed. Subsequently, a list of points is established, marking the beginning, encountered Nodes and end of the line of travel. The List is then trimmed by testing linear paths between every third point, if a valid path is found, the middle point is spliced. Then all possible paths that have been trimmed are calculated for distance. the shortest one wins. Below is the code for the algorithm I currently use. its my first attempt at using classes to create an algorithm. Previously I just relied on elaborate arrays. I plan on improving the the process mentioned above by keeping track of distance as each path spreads out from it's starting location. Only the path which is shortest in distance will go through its next iteration. With this method, once a path to the end is found, I can bet it will be shortest, so I won't need to compute all possible paths like I am now. The challenge I've been facing for the past two months is sometimes the Nodes end up in the water, The picture above shows a shoreline where the distance the OVectors travel would place them in the water. Once a node is in the water, it allows the AI to move to it, then there is no shoreline collision geometry for it to encounter, which would keep it on land, and so the AI just walks into the ocean. Big Booo! I've been writing variations of the same function to correct the location of the geometry shown below in Red and Yellow below. But what a long process. I've rewritten this function time and time again. I want it to be, well as the title of this Blog states, Robust, but it's slow going. As of today's date, it's not Robust, and the optimised path-finding algorithm hasn't been written either. I'll be posting updates in this blog entry as I make progress towards my goal. I'll also make mention what I achieve for shortest, long time for pathfinding. Hopefully it'll be below 250 ms. -- - -- - -- - -- - -- - -- - short term goals for the game - -- - -- - -- - -- - -- - -- Badly... SO BADLY I want to be focusing on game content, that's all I've been thinking about. Argh, But this all has to get wrapped up before I can. I got ahead of myself, I'm guilty of being too eager. But there is no sense building game content on top of an engine which is prone to errors. My immediate goals for the engine are as follows: // TO DO's // // Dec 26th 2017 // /* * << IN PROGRESS >> -update path node geometry so no errors occur * -improve path finding alg with new technique * -improve client AI display -only one geometry for high detail, and one for tetrahedron. * -create ability to select many AI at the same time by drawing a rectangle by holding mouse button. * -create animation server to recieve a path and process animation, and test out in client with updates. * -re-write geometry merging function so that the client vertices and faces have a connected Target ID * -incorporate dynamic asset functionality into client. * -create a farm and begin writing AI. * -program model clusters * -sychronize server and client AI. Test how many AI and how quickly AI can be updated. Determine rough estimate of number of players the server can support. * */ see the third last one! That's the one, oh what a special day that'll be. I've created a Project page, please check it out. It gives my best description to date of what the game is going to be about. Originally I was going to name it 'Seed', a family member made the logo I use as my avatar and came up with the name back in 2014. Then just this week I find out that some studio in Europe is making THE EXACT SAME GAME ! WHA??? http://www.pcgamer.com/seed-is-a-hugely-ambitious-in-development-mmo-that-echoes-eve-online-rimworld-and-the-sims/ I'm being facetious, but they're very close to being the same game. Anyways, Mine will be better, you read it here first! hahaha. The project is no longer going to be called Seed, it's instead going to be called what I've always called it and will probably always call it; the game [ edit: 02/02/18 Some new screen shots to show off. All the new models were created by Brandross. There are now three earth materials, clay, stone and marble. There are also many types of animals and more tree types. ] Thanks for reading and if you've got anything to comment on I welcome it all. Awoken
  11. Hi, I am new to Game Development and am currently making my first game in Unity using c#. I am a second year uni student studying computer science (internet security specialization). I am new to unity and have had trouble understanding how the game engine actually functions and how I should use the engine to my advantage when programming. Currently I am making a RPG and want to implement an efficient and scalable item database. My plan is to store all items in the game in an xml database using the built in unity xml serializer. I have an abstract class item -> weapon, armour, potion, ring etc. Each of these classes have respective values (damage, cost etc.). For a relatively generic and straightforward item system: How would you organize your code? What interfaces/classes/other would you implement; why? In your experience what kinds of issues have you run into and how did you work around them? Is there any other advice with regards to rpg design in general?
  12. I need to program a game, in task manager. How do i do it?
  13. (Posted this in graphics forum too, which was perhaps the wrong forum for it) Hey, I was wondering if on mobile development (Android mainly but iOS as well if you know of it), if there is a GPUView equivalent for whole system debugging so we can figure out if the CPU/GPU are being pipelined efficiently, if there are bubbles, etc. Also slightly tangent question, but do mobile GPU's have a DMA engine exposed as a dedicated Transfer Queue for Vulkan? Thanks!
  14. I am coding the rasterization of triangles by the baricentric coordinate method. Look a lot of code and tutorials that are on the web about the optimization of this algorithm. I found a way to optimize it that I did not see it anywhere. I Only code the painting of triangles without Zbuffer and without textures. I am not comparing speeds and I am not interested in doing them, I am simply reducing the amount of instructions that are executed in the internal loop. The idea is simple, someone must have done it before but he did not publish the code or maybe in hardware it is already that way too. It should be noted that for each horizontal line drawn, of the three segments, you only need to look at one when going from negative to positive to start drawing and you only need to look at one when it goes from positive to negative when you stop drawing. I try it and it works well, now I am implementing a regular version with texture and zbuffer to realize how to add it to this optimization. Does anyone know if this optimization is already done? The code is in https://github.com/phreda4/reda4/blob/master/r4/Dev/graficos/rasterize2.txt From line 92 to 155
  15. Hi. It's been a while since I posted here, and my last posts are almost about this exact same subject. Just saying to demonstrate how annoying this is to me. Here is the problem : I'm trying to make a decent raycaster in C#. The main issue is that for this to happen, I need pixel by pixel drawing. My previous raycaster used VS GDI+, and trough several tricks involving pointers and filling a bitmap byte by byte, I was able to obtain half decent results, and make an online server-client style 3d engine complete with a map builder and several really cool features. I unfortunately wasn't able to expand the project further due to poorly written code (I am an hobbyist, I study Business Administration at Uni) and the fact that my quick hack for performance was barely able to carry the bare minimum of what I needed to make a very bare bone raycaster possible. This came with very real sadness, the realization that the project I spent almost 2 years on was essentially useless, bloated and impossible to expand on. Enough background. Now, starting anew, my main concern is to find a way to gain fast pixel by pixel control over the screen. I'm using SFML and C#. My current testbench is pretty simple, I'm using a method I found on the internet written for C++. I Adapted it for C#. I'm filling a Color[,] array (each color is a pixel) and then I copy the RGB values inside a byte[] array before moving them inside the texture buffer. I then display the texture on the screen. I'm not sure what the bottleneck is, the application is faster than my previous one, but it's still too slow for my liking. Raycasters work by redrawing stuff ontop of other stuff, and I fear that adding more stuff would creep it to an halt. I'm posting what I have as a testbench right now, any help would be greatly appreciated. Keep in mind I am not a professional programmer by any mean, I am pretty uncomfortable with pointers and true 3d stuff, but I will use them if I must. using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using SFML.Audio; using SFML.Graphics; using SFML.System; using SFML.Window; namespace RayCastFF { class Program { public static int TestCounter = 0; public static Color[,] ScreenBuffer = new Color[640, 360]; //an array containing the color of all the pixel, this is intended to be the main target of all manipulation and draw call public static Texture MainViewPort = new Texture(640, 360);//main screen texture unsafe static void Main(string[] args) { //MAINWINDOW SETUP RenderWindow window = new RenderWindow(new VideoMode(640, 360), "RayCaster"); while (window.IsOpen)//MAIN GAME LOOP { //CALL FOR UPDATE Update(); //DRAW window.Clear(); window.DispatchEvents(); Sprite mainviewport = new Sprite(MainViewPort); window.Draw(mainviewport);//draw the texture over the screen window.Display(); //TAKE INPUT } } static void Update() { TestCounter++; if (TestCounter > 639) { TestCounter = 0; } //RESET THE BUFFER (COULD BE REMOVED LATER I GUESS) for (int x = 0; x < 640; x++) { for (int y = 0; y < 360; y++) { ScreenBuffer[x, y] = Color.Black; } } //DO STUFF DrawLine(Color.Red, TestCounter, 200, 100); //(for this test, i simply draw a moving line) //WRITING THE BUFFER INTO THE IMAGE //THIS SHOULD ALWAYS BE THE LAST STEP OF THE UPDATE METHOD byte[] pixels = new byte[640 * 360 * 4]; //640 x 360 pixels x 4 bytes per pixel Color[] cpixels = new Color[640 * 360];//intermediary step to keep everything clear for (int x = 0; x < 640; x++) { for (int y = 0; y < 360; y++) { cpixels[x+(640*y)] = ScreenBuffer[x, y];//make an intermediary array the correct dimention and arrange the pixels in the correct position to be drawn (separate step to keep everything clean, I find this operation incredibly confusing mainly because I had no idea how the pixels are supposed to be arrenged in the first place(still kind of dont)) } } for (int i = 0; i < 640 * 360 * 4; i += 4)//fill the byte array { pixels[i + 0] = cpixels[i / 4].R; pixels[i + 1] = cpixels[i / 4].G; pixels[i + 2] = cpixels[i / 4].B; pixels[i + 3] = cpixels[i / 4].A; } MainViewPort.Update(pixels);//update the texture with the array } //[X , Y] static void DrawLine(Color color, int Wpos, int Ytop, int Ybottom)//simple draw method making a vertical line { for (int y = Ybottom; y < Ytop; y++) { ScreenBuffer[Wpos, y] = color; } } } } What I'd like to end up with is a very fast way to draw the pixels on the window by the abstraction of a single 2d array of 640x360 unit that I could easily and simply manipulate. However, while being simple, it's also somewhat slow. It's also using 30% GPU load for some reason on a 1070GTX 8GB. Again, any help would be greatly appreciated. Thanks in advance.
  16. Hello all, My question is a bit hard to describe but hopefully it will do... I just wonder what you guys think is the 'best' way of getting info about the model in your view(s).. To clearify (i hope ;-) ) If the model is updating itself every game-cycle and the (deep) nested objects all do there jobs how do you get info where only the view is interested in? So my question is not how to do it but more what do you people think is the best way to do it ? Regards, Alex
  17. How I halved apk size

    Originally posted on Medium You coded your game so hard for several months (or even years), your artist made a lot of high-quality assets, and the game is finally ready to be launched. Congratulation! You did a great job. Now take a look at the apk size and be prepared to be scared. What is the size — 60, 70 or even 80 megabytes? As it might be sounds strange to hear (in the era of 128GB smartphones) but I have some bad news — the size it too big. That’s exactly what happened to me after I’ve finished the game Totem Spirits. In this article I want to share several advises about how to reduce the size of a release apk file and yet not lose the quality. Please, note, that for development I used quite popular game development engine Libgdx, but tips below should be applicable for other frameworks as well. Moreover, my case is about rather simple 2D game with a lot of sprites (i.e. images), so it might be not that useful for large 3D products. To keep you motivated to read this article further I want to share the final result: I managed to halve the apk size — from 64MB to 32.36MB. Memory management The very first thing that needs to be done properly is a memory management. You should always have only necessary objects loaded into the memory and release resources once they are not in use. This topic requires a lot of details, so I’d rather cover it in a separate article. Next, I want to analyze the size of current apk file. As for my game I have four different types of game resources: 1. Intro — the resources for intro screen. Intro background Loaded before the game starts, disposed immediately after the loading is done. (~0.5MB) 2. In menu resources — used in menu only (location backgrounds, buttons, etc). Loaded during the intro stage and when a player exits a game level. Disposed during “in game resources” loading. (~7.5MB images + ~5.4MB music) 3. In game resources — used on game levels only (objects, game backgrounds, etc.). Loaded during a game level loading, disposed when a player exits the game level. Note, that those resources are not disposed when a player navigates between levels (~4.5MB images + ~10MB music) 4. Common — used in all three above. Loaded during the intro stage, disposed only once the game is closed. This one also includes fonts. (~1.5MB). The summed size of all resources is ~30MB, so we can conclude that the size of apk is basically the size of all its assets. The code base is only ~3MB. That’s why I want to focus on the assets in the first place (still, the code will be discussed too). Images optimization The first thing to do is to make the size of images smaller while not harming the quality. Fortunately, there are plenty services that offer exactly this. I used this one. This resulted in 18MB reduction already! Compare the two images below: Not optimized Optimized the sizes are 312KB and 76KB respectively, so the optimized image is 4 times smaller! But a human eye can’t notice the difference. Images combination You should combine the same images programmatically rather than having almost the same images (especially if they are quite big). Consider the following example: Before After God of Fire God of Water Rather than having four full-size images with different Gods but same background I have only one big background image and four smaller images of Gods that are then combined programmatically into one image. Although, the reduction is not so big (~2MB) for some cases it can make a difference. Images format I consider this as my biggest mistake so far. I had several images without transparency saved in PNG format. The JPG version of those images is 6 times more lightweight! Once I transformed all images without transparency into JPG the apk size became 5MB smaller. Music optimization At first the music quality was 256 kbps. Then I reduced it to 128 kbps and saved 5MB more. Still think that tracks can be compressed even more. Please, share in comments if you ever used 64 kbps in your games. Texture Packs This item might be a bit Libgdx-specific, although I think similar functionality should exist in other engines as well. Texture pack is a way to organize a bunch of images into one big pack. Then, in code you treat each pack as one unit, so it’s quite handy for memory management. But you should combine images wisely. As for my game, at first I had resources packed quite badly. Then, I separated all transparent and non-transparent images and gained about 5MB more. Dependencies and Optimal code base Now let’s see the other side of development process — coding. I will not dive into too many details about the code-writing here (since it deserves separate article as well). But still want to share some general rules that I believe could be applied to any project. The most important thing is to reduce the quantity of 3d party dependencies in the project. Do you really need to add Apache Commons if you use only one method from StringUtils? Or gson if you just don’t like the built-in json functionality? Well, you do not. I used Libgdx as a game development engine and quite happy with it. Quite sure that for the next game I’ll use this engine again. Oh, do I need to say that you should have the code to be written the most optimal way? :) Well, I mentioned it. Although, the most of the tips I’ve shared here can be applied at the late development stage, some of them (especially, optimization of memory management) should be designed right from the very beginning of a project. Stay tuned for more programming articles!
  18. Sorry for making a new thread about this, but I have a specific question which I couldn't find an answer to in any of the other threads I've looked at. I've been trying to get the method shown here to work several days now and I've run out of things to try. I've more or less resorted to using the barebones example shown there (with some very minor modifications as it wouldn't run otherwise), but I still can't get it to work. Either I have misunderstood something completely, or there's a mistake somewhere. My shader code looks like this: Vertex shader: #version 330 core //Vertex shader //Half the size of the near plane {tan(fovy/2.0) * aspect, tan(fovy/2.0) } uniform vec2 halfSizeNearPlane; layout (location = 0) in vec3 clipPos; //UV for the depth buffer/screen access. //(0,0) in bottom left corner (1, 1) in top right corner layout (location = 1) in vec2 texCoord; out vec3 eyeDirection; out vec2 uv; void main() { uv = texCoord; eyeDirection = vec3((2.0 * halfSizeNearPlane * texCoord) - halfSizeNearPlane , -1.0); gl_Position = vec4(clipPos.xy, 0, 1); } Fragment shader: #version 330 core //Fragment shader layout (location = 0) out vec3 fragColor; in vec3 eyeDirection; in vec2 uv; uniform mat4 persMatrix; uniform vec2 depthrange; uniform sampler2D depth; vec4 CalcEyeFromWindow(in float windowZ, in vec3 eyeDirection, in vec2 depthrange) { float ndcZ = (2.0 * windowZ - depthrange.x - depthrange.y) / (depthrange.y - depthrange.x); float eyeZ = persMatrix[3][2] / ((persMatrix[2][3] * ndcZ) - persMatrix[2][2]); return vec4(eyeDirection * eyeZ, 1); } void main() { vec4 eyeSpace = CalcEyeFromWindow(texture(depth, uv).x, eyeDirection, depthrange); fragColor = eyeSpace.rbg; } Where my camera settings are: float fov = glm::radians(60.0f); float aspect = 800.0f / 600.0f; And my uniforms equal: uniform mat4 persMatrix = glm::perspective(fov, aspect, 0.1f, 100.0f) uniform vec2 halfSizeNearPlane = glm::vec2(glm::tan(fov/2.0) * aspect, glm::tan(fov/2.0)) uniform vec2 depthrange = glm::vec2(0.0f, 1.0f) uniform sampler2D depth is a GL_DEPTH24_STENCIL8 texture which has depth values from an earlier pass (if I linearize it and set fragColor = vec3(linearizedZ), it shows up like it should, so nothing seems wrong there). I can confirm that it's wrong because it doesn't give me similar results to what saving position in the G-buffer or reconstructing using inverse matrices does. Is there something obvious I'm missing? To me the logic seems sound, and from the description on the Khronos wiki I can't see where I go wrong. Thanks!
  19. Hello everyone! Right now I am writing my own physics engine in java for LWJGL3 3D game and I would like to consult my ideas with you guys. It's not about writing the actual code, but asking if my solution is good, and/or can it be better. And I would like to make it easy to refactor to much others render engine and "game-loop engine". So lets get started! The base game architecture looks like this: The Core holds just the information about the game itself, so whenever I decided to write some new game I would just have to edit this module. The render engine holds just the information about rendering the models, however it only gets the material and mesh data from the model. The Model module holds 4 basic information about model: Models - basic Model that holds only information about ModelView, position, rotation and scale. Other types of models inherits it and add unique params (AnimatedModel adds Animation mesh data). ModelView is build of ModelPart which are build from TexturedMeshes (will be explained later). Loaders - classes to load specific model type (i.e. Assimp loader for *.obj files) and process classes - to create necessary data to render model (ie. create Mesh which holds vboID, vertices/textures/normals arrays etc). Components - every model can have some component, ie. moveable - which allows to move the object arround the world. Materials - used together with Mesh to create TexturedMesh. Material holds information about diffuse, ambient, etc colors, diffuse, normal textures. PhysicsEngine module has the core (initiation of physics world), collision detection, CollidableComponent (inherit from BaseComponent) and Shapes (i.e AABB, Sphere, Cylinder, MeshCollider). This is the part I would like to discuss with you guys (however if you have something to say about other parts - please go for it!). Core: PhysicState - initiation of physics world, update methods, holds default data (i.e. Default narrow collision shape) Collision: Broad Phase Collision Detection (BPCD) and Narrow Phase Collision Detection (NPCD) CollidableComponent - component that can be added to model to make it collidable (in future I was planning to add other components such as: WindComponent for grass model - adds reaction to wind). Only models with CollidableComponent are checked in BPCD and NPCD, the rest are ignored. CollidableComponent has also a boolean isMoveable - i.e. Rock - it is collidable, but its never, ever gonna move. so it doesn't have to be checked with other non-moveable components at BPCD and NPCD. Shapes - basic shapes and info about them (AABB - points min/max, Sphere - center, radius, etc.) More info are shown below on diagram: Right now it works like this: I create a model and add a CollidableComponent to it like this: public CollidableComponent(Model model, TypeOfShape typeOfShape, boolean isMoveable) TypeOfShape declares the basic Broad Phase Collision Shape (AABB, Sphere, Cylinder, Mesh). The Shape is created from the raw data of the model and transformed to actual data (position, rotation*, scale).If I want to I can add the Narrow Phase Collision Shape MAP - which declares the CollisionShape for each Model Part inside the ModelView. In most cases for me it's going to be MeshCollider (since the game I'm planning to create is in Low Poly Style). IDEA 1: When the CollidableComponent is created it is automatically added to BPCD map to check its collision. Of course it's just temporary, later on I would have to set limit to the map size (i.e. to 500) or split the world to smaller parts and add just the entities which are in this world's part to BPCD. So this is the part where you guys could give me some advice IDEA 2: Collision Detection update: Right now the update works like this: public void update() { narrowPhase.narrowPhaseCollisionMap.clear(); if (!broadPhaseCollisionMap.isEmpty()) { for (Model model : broadPhaseCollisionMap.keySet()) { if ((model.getComponent(CollidableComponent.class)).isMoveable()) { for (Model model2 : broadPhaseCollisionMap.keySet()) { if (!model.equals(model2)) { CollisionShape cs1 = getCollisionShape(model); CollisionShape cs2 = getCollisionShape(model2); if (checkCollision(cs1, cs2)) { narrowPhase.narrowPhaseCollisionMap.add(model); narrowPhase.narrowPhaseCollisionMap.add(model2); } } } } } } if (!narrowPhase.narrowPhaseCollisionMap.isEmpty()) { narrowPhase.update(); } } so: 1. It checks if the BPC Map is not empty, and if its not it proceed, else nothing happens. 2. It loops through all the models inside the map and check if it's isMoveable - as I said, I ignore collision detection with objects that doesn't move 3. 2nd loop throught models and check the model from 1st loop isn't the model from the 2nd loop. If they are - lets ignore it. 4. If they are 2 different models it retrieve the BPC shapes from the models and if it is the moveable model it updates its CollisionShape data (by the current the position, rotation,* scale*) 5. Check the intersection between these 2 shapes, and if it true it's added to NPC List 6. After the BPCD loops if the NPC List is not empty it runs its update The NPCD update is pretty similar to BPCD with just 2 exceptions: 1. It used the List<Models> instead of Map<Model,CollidableComponents> (from models I can retrieve the info about the CollidableComponent, so I might use the List in BPCD aswell instand of Map **) 2. It checks the collision intersection same as for BPCD but for each ModelPart of Model_1 with each ModelPart of Model_2, returns true and/or excact collision point, etc, and breaks this model-model loop check (so it doesn't check if other parts of the models collide with each other). With my calculations for 50 objects - 27 is static and 23are movable with random position (but some collides): the NP Took: 0.0ms for: 1224 collision checks and: 24 positive collisions for BPCD Took: 10. ms for: 55776 collision checks and: 576 positive collisions for NPCD Took: 11.0ms in total for BPCD and NPCD I can see a huge space to improve the Collision Detection update methods, but I can't find them, so I hope you guys can help me out Maybe not all models has to be checked in NPCD, i.e. check how far from camera they are, and after some point just ignore NP since it won't be anyhow visible? Well, that's all! Sorry for a bit long post, but I hope you at least enjoyed reading it *Actually just forgot about adding it to calculation **Just came to my head when I was writing this topic
  20. Hey everyone! Currently I am making my engine and I got one thing I am worried about. I am using text data format to store my assets (e.g. JSON objects or kinda "human-readable" formats), it requires to register every field I want to serialize and read it manually from file data: void Resource::Save(IFile* file) { file->Serialize("myField", myFieldValue); } void Resource::Load(IFile* file) { file->Deserialize("myField", &myFieldValue) .. and so on, manually, nothing else! } But I can't breathe calmly since I saw UE4 serialization/asset storage system, it uses rtti, it's MUCH easier to serialize objects and now I am unsure which method I should use: should I give all responsibility to rtti system(with lots of code hidden) or load everything I need manually just like first code example? I know I can code rtti that way so it will output "human-readable" files, but is it good thing to use?
  21. Hey devs! Want to get rid of all the bugs in your game? I co-own a video game QA company called Level_0 Studios, we perform professional QA testing for game developers. Our goal is to help you create bug free games your players will enjoy. Partnering with Level_0 allows you to focus more time towards game development while we find those pesky bugs. If you’re interested and in need of professional game testers contact us at contact@level0studios.com and check out our website at https://level0studios.com for more information.
  22. Hi all, More than a decade ago, a problem came up on this forum for computing a fast transpose of a 3x3 matrix using SSE. The most sensible implementation stores the matrix internally as a 3x4 matrix (so, one row stores 4 elements, aligned in a vector). A version, which I believe to be the fastest currently known, was presented: I am pleased to report that I have been able to come up with a version which should be faster: inline void transpose(__m128& A, __m128& B, __m128& C) { //Input rows in __m128& A, B, and C. Output in same. __m128 T0 = _mm_unpacklo_ps(A,B); __m128 T1 = _mm_unpackhi_ps(A,B); A = _mm_movelh_ps(T0,C); B = _mm_shuffle_ps( T0,C, _MM_SHUFFLE(3,1,3,2) ); C = _mm_shuffle_ps( T1,C, _MM_SHUFFLE(3,2,1,0) ); } This should be 5 instructions instead of ajas95's 8 instructions. Of course, to get that level of performance with either version, you need to inline everything, or else you spend tons of time on moving floating point arguments to/from input registers. The other thing that is crucial is that the instruction set be VEX encoded. This allows generating instructions that take three arguments, like `vunpcklps`, instead of instructions like `unpcklps` that take only two. VEX is only available in AVX and higher (usually passing e.g. `-mavx` is sufficient to get the compiler to generate VEX instructions). -G
  23. After a feeled million hours of coding in the past 16 years there have been many ways to write code in many different languages. Some seemed correct to the time they were used, some seemed to be too strict or too chaotic and I also evolved my coding style with each new line written. Now considering the results of over 5 years in professionall game development, tools and engine code as hobbyist and on small and large commercial projects up to AAA titles, there are still many ways one could write code in different languages but also in the same language on different projects in one and the same but also different companies. I mostly agree with; see some trends in C#, C++ coding guidelines that are fully worth to go for but the major difference is on the naming conventions. Because I have currently to write my own coding guidelines (not for a special project but primary as a personal convention to refer to when coding) and seek for a way I'm happy with, I did some research on different guidelines and came up with following references: When Epic Games write about Unreal This seems a bit confusing when seeking for some type like Animation or Skin (that are both different prefixed with A and F) but prevents various naming conflicts to types and variables when writing a function that accepts FSkin Skin as parameter for example. Googles c++ guidelines point into a completely different direction when they write So they heavily make use of typos, underscores and also lower case prefixes to identify different kinds of member, static, nonstatic and function names and in the same breath except there rules for various special cases. Some other examples from different projexts I was invovled to also use and do not use prefixing types or use underscores class Class { const <type> cConstant; const <type> Constant; const <type> __Constant; <type> _myClassMember; <type> _MyClassMember; <type> myClassmember; <type> mMyClassMember; <type> function(<type> parameter); <type> Function(<type> parameter); <type> Function(<type> aParameter); } class NAClass //avoid using namespaces, instead prefix anything with a 2 letter namespace like identifier { ... } Dont need to mention that Visual Studio will raise a Warning/Exception that a type is named as same as a function parameter when using a class class Container { private int size; //current size public Resize(int size) //will cause compiler telling that type matches a member type { //do resize here } } So in the end anyone does he or she thinks that it is worth to be done and so me do too. I would like to hear your opinions to why and what codings style do you prefer or are involved to in whatever way. What do you think makes a good standard especially for the most common point, Naming Convetions? Will be corious to read your opinions
  24. Hi, I am releasing my 2d game on Steam, so sent it to review and they said it has some black and white rectangles covering parts of the screen. I don't have this issue on my old pc of course (amd 6670 vga), and I tested on a laptop too (amd gpu), without any problem. The game uses Direct3d11 with c++, nothing fancy, 2 layer of tiles, and some sprites for decorations and some postprocess effects. I have no idea what to do. Released it a while ago on Itch.io, had some 20+ downloads, nobody said anything about not working - or anything at all, sadly. So anyone does have any tips, how to figure out a graphical bug that is not reproductable on your end, and you doesn't even have a screenshot?
  25. I've been starting to optimize my code in anyway possible. I saw that some cpu's actually have 256-bit SIMD, but I was wondering if there is a way to detect this and fallback to the 128-bit on an unsupported cpu, or how else to deal with this.
  • Advertisement