Map - 3D Exploration Implementation

[raniabbrk]

Try to implement the map in 3D, where users can scroll and explore the sky:

• Investigate available libraries or APIs that support 3D maps and sky exploration.
• Develop a basic 3D map that allows users to scroll, zoom, and explore different parts of the sky.
• Ensure smooth performance and responsiveness for user interactions.

[AdrienBousquieEPFL]

Starting OpenGL ES Learning for 3D Sky Map

As discussed, OpenGL ES appears to be the most suitable option for implementing the 3D map of the sky. I have found multiple key resources to start my learning process:

1. OpenGL ES Documentation by Android
2. Learn OpenGL ES
3. Learn OpenGL
4. OpenGL Tutorials

I will begin with the Android tutorial and update the issue regularly as I make progress.

[AdrienBousquieEPFL]

OpenGL ES Tutorial 1 Progress

Link

Tutorial Steps:

• [x] Build an OpenGL ES environment (1h)
• [x] Define shapes (30min)
• [x] Draw shapes (1h15min)
• [x] Apply projection and camera views (1h)
• [x] Add motion (15min)
• [x] Respond to touch events (30min)
• [x] Create APKs for different GL textures (skipped as unrelated to what we want to learn for now)

[AdrienBousquieEPFL]

OpenGL ES Tutorial Completion

I’ve completed the first OpenGL ES tutorial, which helped me grasp the basics of OpenGL ES and provided a basic understanding of the general structure of OpenGL code.

I will try to read code of different repositories implementing the skymap using OpenGL such as Stellarium or Stardroid to understand how they coded their own skymap.

[AdrienBousquieEPFL]

Update on Stardroid Repository Review and Next Steps

I reviewed the Stardroid repository, which is an OpenGL ES-based implementation written in Java. It closely aligns with our project's goals and has a similar structural approach to what we aim to implement. I recognized some elements from the initial OpenGL ES tutorial I completed. However, Stardroid includes numerous additional considerations and optimizations that weren’t covered in the basic tutorial.

To bridge this gap, I believe it would be most efficient to follow a more advanced tutorial, such as the 4th tutorial mentionned. This resource should help build the knowledge required to move closer to our goal and enable a more effective adaptation of Stardroid’s advanced techniques into our 3D sky map.

[AdrienBousquieEPFL]

Progress Update:

• Completed Part 5 of the OpenGL tutorial, gaining a strong foundational understanding. (~5h of work)
• Only three more parts remain before I can start implementing the camera feature, a critical part of our project.

Goal for End of Sprint: Basic Map Implementation

• Primary Objective: Position a camera in 3D space with the ability to look around, displaying stars at various coordinates to begin creating an interactive starmap experience.
• Time Estimate: ~8 hours needed.

Next Steps & Considerations:

• Testing: Will conduct speed and performance tests to evaluate how the app handles a large number of objects (stars).
• Optimization: Based on performance, we’ll determine if optimizations are necessary, as this may add workload and complexity to the project.

[AdrienBousquieEPFL]

Sprint Summary and Next Steps

I’ve completed my research for this sprint, and I’m pleased with the progress made. Starting with no prior OpenGL ES experience, I’ve managed to create a rotating 3D pyramid—a significant step given the library's complexity. Although I aimed to have randomly positioned stars in 3D and a functional camera, I'm close to these goals even if they weren’t fully reached within this sprint.

Findings from the Stardroid Repository

After revisiting the Stardroid repository, I've concluded that directly using their code may be impractical. They use an earlier version of OpenGL ES, which differs from what we’re working with. Given the challenges of adapting their code, it seems more efficient to treat Stardroid as an inspiration rather than a direct source.

Moving Forward: Key Considerations

Since we need to decide whether to continue on this path, here’s what to expect:

1. Main Work Areas

   • 3D Sky Map Development:

     • Implement a 3D map with stars, planets, and other elements, with free movement around the map.
     • This will require creating several classes for different components: a camera class, astronomical elements, and a renderer class to handle drawing, as well as optimizing performance to render only visible elements.
     • Currently, I'm the only one with knowledge of OpenGL ES, so this will largely depend on my progress.

   • Code Structure and Data Integration:

     • Define a structured approach to connect OpenGL ES 3D UI with external data sources (e.g., star catalogs).
     • Integrate location data and sensor readings to enable interactions like pointing the phone to see specific stars or planets.

   • Application Integration:

     • Connect the OpenGL ES activity with other parts of the app, including data fetching and location services.

2. Challenges and Timeline

   • Since OpenGL ES is new to me, it's hard to anticipate all potential issues, but early tutorials have gone smoothly, which is promising.
   • This work could extend through the project’s deadline and likely require a focus on this area alone.
   • It’s realistic to aim for a functional 3D star map with gyroscope support. However, achieving flawless performance optimization will be challenging within the timeframe.

Planning Discussion

If we decide to continue, we’ll need to meet as a team to create a clear, comprehensive plan: determining exactly what features we want, what resources and steps are necessary to achieve them, and estimating the time required. Dividing the project scope in advance will be essential to fit these goals into our timeline.

Despite some uncertainties, I’m optimistic that we can develop a functional, interactive 3D map that offers a meaningful experience by the project’s end.

[AdrienBousquieEPFL]

Next Steps

As discussed, I’ll aim to complete the initial goal by Saturday: implementing a camera with stars positioned around it. From there, I’ll outline a plan for the 3D map to have something meaningful ready for review by Sunday.

Afterward, we’ll have a final discussion to determine whether committing to the 3D map in OpenGL is realistically achievable within our timeline.

[AdrienBousquieEPFL]

Saturday Task Update: Camera Movement Progress

I spent the planned 2 hours today working on camera movement implementation. While the basic camera movements are functional, the implementation turned out to be more complex than anticipated. I initially underestimated the range of methods available to move a camera in a 3D space.

Here are some key challenges encountered:

• Input Methods: The camera can be controlled via swiping, the gyroscope, or buttons, which complicates the task depending on the input chosen.
• Mathematical Complexity: OpenGL relies heavily on linear algebra, so implementing the right 3D transformations requires precise mathematical computation to achieve the desired effect for moving and positioning 3D objects.

Moving Forward: Defining a Clear Plan

With a better understanding of these complexities, I feel ready to draft a structured plan for developing the 3D map. The goal of this plan will be:

• Identifying Potential Challenges: Mapping out potential issues we may encounter.
• Establishing a Code Structure: Defining a clear, modular code structure that will support steady progress and align with our project needs.
• Assessing Feasibility: Realistically gauging the scope of this implementation and anticipating any unforeseen needs for the project.

Next Steps: Tomorrow, I’ll work on defining this code structure and 3D map plan. Once complete, we can review it together to decide whether committing to a full 3D map in OpenGL is achievable within our timeline.

[AdrienBousquieEPFL]

Commitment to 3D Map Implementation

We are committing to the development of the 3D map as a core, meaningful feature, acknowledging that this task will be quite challenging. This comment will serve to close this issue as we prepare to refactor the existing code in #66, which was originally coded for the tutorial, to begin the implementation of our OpenGL project.

To enhance our team’s knowledge, @rihabbelmekki and @raniabbrk will start learning OpenGL ES by completing the first issue, which involves rendering a basic OpenGL application. With this effort, we will have three team members familiar with OpenGL, allowing us to collaborate more effectively as we move forward with the implementation.