Matias Calegaris

Argentum Online is a 24-year-old game developed in VB6. With the intention of migrating the code to C++, we decided to re-implement the UI in a more modern language for easier maintenance and extension. This also served as a crucial step towards migrating the entire project from VB6 to C++.

To accomplish this, I utilized a C++ library to run a browser and created an API for VB6 to manage all interactions within the game. However, there was a challenge as the JavaScript library was built for 64-bit systems, while VB6 only runs as a 32-bit process. To address this, I implemented a background process to run the web, developed an API in VB6, and synchronized both processes using shared memory.

Given that keyboard and mouse inputs were captured in the VB6 process, while all UI interactions, such as button presses, were handled in a separate process, efficient communication was essential to synchronize both processes swiftly. This was crucial to ensure that players did not experience any lag or delay while playing.

Public React Repo:
https://github.com/matiascalegaris/ao-ui

VB6 client public repo:
https://github.com/ao-org/argentum-online-client

VB6 Server public repo:
https://github.com/ao-org/argentum-online-server

This technology demo is an augmented reality application, which shows the integration between Unity, OpenCV, C++, ARToolkit. The idea behind the app is a small game where multiple users (interacting via a local network multiplayer) fight against an enemy and build the scenario using real world objects.

This app works on both iOS and Android, C++ the native code used to do image processing (which uses OpenCV) is compiled on each platform without changes (100% cross platform).

Features:
• Real time multiplayer (via Unity mulitplayer)
• Image processing (https://youtu.be/774VfFo_oJA, the scenario is generated scanning the image for different colors and then creating the proper elements, like fire).
• Augmented reality (used to identify the 3D that the scenario will be placed on and allow camera's tracking).
• Shading (vertex shaders used to do not render below the real world)
• Native code linking (via C#'s pInvoke and native build DLLs).

Using Oculus Rift's Unity integration (4.2, several years ago), we implemented an application that allows us to test the psychological effects of certain scenarios like being at a building's rooftop, walking through reduced spaces, and fear of certain animals (e.g., spiders). The idea is to build an immersive experience to users that can't be exposed to those situations in real life.

Using OpenCV under C++ plus MFC, we developed an application to allow calibration of a set of images taken by a 360° photo booth. This is a device comprised of an array of cameras that take a photo at exactly the same time. Due to construct issues, the cameras never have the same focal point or the same orientation.

This application allows the user to, once the device is installed, use the application to aid the software calibration of the device (the application loads the set of photos and automatically tries to calibrate them based on the feedback provided by the calibration element, a red and green tube).

Once the calibration is done, a set of parameters is saved for each camera so the image processing server can call an external process providing these parameters to warp the images (we also developed that application).

Inspired by the beloved SpongeBob show, this game features four exciting mini-games.

During development, I played a crucial role in creating two of these games: an isometric skateboarding adventure and a surf challenge. Additionally, I contributed to the shared resources used across all four mini-games.

I also expanded the 2D engine capabilities to include support for entities and cameras.

In 'Art of Ink,' a drawing game, players create a tattoo while managing their client's pain threshold.

My responsibilities encompassed the gameplay, focusing on optimizing input detection for a seamless drawing experience. Additionally, I implemented collision detection for the valid drawing areas, ensuring players accurately inked the designated spots while tracking their progress.

In 'Save the Turtles,' a puzzle game, the objective is to align three or more turtles of the same color while navigating various obstacles that endanger them.

My involvement spanned across all facets of the game. This included expanding the engine to accommodate DSi features such as integrating sound APIs and developing resource managers. I also worked on key gameplay elements such as line matching, the scoring system, and the user interface (UI) development.

Based on the requirements of the Flare3D's team, we made a JS library based on Flare's AS3 API but implemented with WebGL. The idea behind the project was to explore WebGL's capabilities so WebGL + JS could be a build target for Flare Studio.

We used TypeScript as a base language to improve code quality since we were used to strongly typed languages. The last version of the API is able to load .fz3d files and manages several shader materials (diffuse, specular, normal map, etc) and implements a scene graph, matching with the core Flare's rendering API.

I worked on a project featuring a collection of 101 mini-games. My role involved implementing 10 of these mini-games, ensuring they adhered to the game design guidelines and integrating assets provided by the artist.

In Shrek's Carnival Craze for Nintendo DS, I implemented the gameplay of 10 out of the 28 mini-games. This involved adhering to the game design guidelines and integrating assets provided by the artist.

This project is a messenger service where users can send their desired product to other locations, and another type of user (shipper) can pick up the package and deliver it. The admin site was made with Laravel PHP and the mobile applications iOS (Swift) and Android (React Native). We also used Firebase for the notification system.

Once a user submits their desired location to send the package, the shipper app tracks it and searches for messengers available to deliver it. After arriving and tracking the shipper's GPS, the user can confirm the shipment and the transaction takes place using MercadoPago.

I built the iOS application from scratch using Swift and finished the development of the Android app done by a third party with React Native.

Create an Android application to track the company workforce on the streets, providing the employee with the locations required to visit every day and the task to perform on each place with a report to fill to track any issues.

The applications tracks daily routes and the supplies required for the whole day and for every location.

This app was made with Xamarin Android

During 2018, we built this platform for an undisclosed client. It is a end to end system to manage restaurant menues and ordering. It has several components including the point-of-sale system, the in•restaurant ordering system (both for tablets), an online back office to manage the menues and restaurants (because is multi•user, multi•restaurant) and an Android/iOS app for pre-ordering outside the restaurant and then continuing the experience within the same app at the table.

I defined the system architecture and implemented all the mobile apps using ionic:
• Kiosk tablet app for the customers
• Kiosk tablet app for the restaurant to handle the orders
• Android/iOS app for the user outside the restaurant.

The Robotics Tournament is a national contest for students, focused on solving global problems. This year's challenge was ocean cleaning using robotics. We developed an app ecosystem to help report match scores in real time. The platform handled tournament setup and progression as well. Solving challenges in a really crowded place where wifi networks can't be made reliable, we implemented a communication system to minimize network latency.

The system has four components: a server to manage the data, the operation room desktop app where we can switch the screen content and advance the tournament; and two mobile app (for referees and for assistants, respectively). We also developed the inter-app interactions necessary to facilitate real time scoring, a feat involving cooperation between the operator, referee, and assistant.

We used Unity3D on the server. For the operator app, we used Angular and Electron to get a desktop build of our web app in order to give the user a non-browser-dependent, desktop experience. And finally, we used Ionic for the mobile app, implementing a responsive design for tablets and cell phones alike, since it was necessary to anticipate potential backup devices of a variety of screen sizes.

For product branding in a music event, I developed a game where the user has to pose and select a music band album as a background. Then the picture is created and he can share it on social media.