// Load textures for cardboard into 'materials_'. The 'renderer_' and
// 'asset_manager_' members have been initialized at this point.
bool Game::InitializeAssets() {
// Load up all of our assets, as defined in the manifest.
// Load the loading-material first, since we display that while the others
// load.
const AssetManifest& asset_manifest = GetAssetManifest();
if (fplbase::GetSystemRamSize() <= kLowRamProfileThreshold) {
// Reduce material size.
asset_manager_.SetTextureScale(kLowRamDeviceTextureScale);
}
asset_manager_.LoadMaterial(asset_manifest.loading_material()->c_str());
asset_manager_.LoadMaterial(asset_manifest.fader_material()->c_str());
for (size_t i = 0; i < asset_manifest.mesh_list()->size(); i++) {
flatbuffers::uoffset_t index = static_cast<flatbuffers::uoffset_t>(i);
asset_manager_.LoadMesh(asset_manifest.mesh_list()->Get(index)->c_str());
}
for (size_t i = 0; i < asset_manifest.shader_list()->size(); i++) {
flatbuffers::uoffset_t index = static_cast<flatbuffers::uoffset_t>(i);
asset_manager_.LoadShader(asset_manifest.shader_list()->Get(index)->c_str());
}
for (size_t i = 0; i < asset_manifest.material_list()->size(); i++) {
flatbuffers::uoffset_t index = static_cast<flatbuffers::uoffset_t>(i);
asset_manager_.LoadMaterial(
asset_manifest.material_list()->Get(index)->c_str());
}
asset_manager_.StartLoadingTextures();
shader_lit_textured_normal_ =
asset_manager_.LoadShader("shaders/lit_textured_normal");
shader_textured_ = asset_manager_.LoadShader("shaders/textured");
// Load the animation table and all animations it references.
motive::AnimTable& anim_table = world_.animation_component.anim_table();
const bool anim_ok =
anim_table.InitFromFlatBuffers(*asset_manifest.anims(), LoadRigAnim);
if (!anim_ok) return false;
return true;
}
// Initialize each member in turn. This is logically just one function, since
// the order of initialization cannot be changed. However, it's nice for
// debugging and readability to have each section lexographically separate.
bool Game::Initialize(const char* const binary_directory) {
LogInfo("Zooshi Initializing...");
#if defined(BENCHMARK_MOTIVE)
InitBenchmarks(10);
#endif // defined(BENCHMARK_MOTIVE)
input_.Initialize();
input_.AddAppEventCallback(AudioEngineVolumeControl(&audio_engine_));
#ifdef ANDROID_HMD
input_.head_mounted_display_input().EnableDeviceOrientationCorrection();
#endif // ANDROID_HMD
SystraceInit();
if (!fplbase::ChangeToUpstreamDir(binary_directory, kAssetsDir)) return false;
if (!LoadFile(kConfigFileName, &config_source_)) return false;
if (!InitializeRenderer()) return false;
if (!LoadFile(GetConfig().input_config()->c_str(), &input_config_source_))
return false;
if (!LoadFile(GetConfig().assets_filename()->c_str(),
&asset_manifest_source_)) {
return false;
}
const auto& asset_manifest = GetAssetManifest();
if (!InitializeAssets()) return false;
if (!audio_engine_.Initialize(GetConfig().audio_config()->c_str())) {
return false;
}
audio_engine_.LoadSoundBank(asset_manifest.sound_bank()->c_str());
audio_engine_.StartLoadingSoundFiles();
InitializeBreadboardModules();
for (size_t i = 0; i < asset_manifest.font_list()->size(); i++) {
flatbuffers::uoffset_t index = static_cast<flatbuffers::uoffset_t>(i);
font_manager_.Open(asset_manifest.font_list()->Get(index)->c_str());
}
font_manager_.SetRenderer(renderer_);
SetPerformanceMode(fplbase::kHighPerformance);
scene_lab_.reset(new scene_lab::SceneLab());
world_.Initialize(GetConfig(), &input_, &asset_manager_, &world_renderer_,
&font_manager_, &audio_engine_, &graph_factory_, &renderer_,
scene_lab_.get());
#ifdef __ANDROID__
if (fplbase::SupportsHeadMountedDisplay()) {
BasePlayerController* controller = new AndroidCardboardController();
controller->set_input_config(&GetInputConfig());
controller->set_input_system(&input_);
controller->set_enabled(ZOOSHI_FORCE_ONSCREEN_CONTROLLER == 0);
world_.AddController(controller);
world_.hmd_controller = controller;
}
#endif // __ANDROID__
// If this is a mobile platform or the onscreen controller is forced on
// instance the onscreen controller.
#if defined(PLATFORM_MOBILE) || ZOOSHI_FORCE_ONSCREEN_CONTROLLER
{
OnscreenController* onscreen_controller = new OnscreenController();
onscreen_controller->set_input_config(&GetInputConfig());
onscreen_controller->set_input_system(&input_);
onscreen_controller->set_enabled(!fplbase::SupportsHeadMountedDisplay() ||
ZOOSHI_FORCE_ONSCREEN_CONTROLLER);
world_.AddController(onscreen_controller);
world_.onscreen_controller_ui.set_controller(onscreen_controller);
#ifdef ANDROID_HMD
world_.onscreen_controller = onscreen_controller;
#endif // ANDROID_HMD
}
#endif // defined(PLATFORM_MOBILE) || ZOOSHI_FORCE_ONSCREEN_CONTROLLER
// If this is a desktop platform and we're not forcing the onscreen controller
// instance the mouse controller.
#if !defined(PLATFORM_MOBILE) && !ZOOSHI_FORCE_ONSCREEN_CONTROLLER
{
BasePlayerController* controller = new MouseController();
controller->set_input_config(&GetInputConfig());
controller->set_input_system(&input_);
world_.AddController(controller);
}
#endif // !ZOOSHI_FORCE_ONSCREEN_CONTROLLER && !defined(PLATFORM_MOBILE)
#ifdef ANDROID_GAMEPAD
{
GamepadController* controller = new GamepadController();
controller->set_input_config(&GetInputConfig());
controller->set_input_system(&input_);
world_.AddController(controller);
}
#endif // ANDROID_GAMEPAD
world_renderer_.Initialize(&world_);
scene_lab_->Initialize(GetConfig().scene_lab_config(), &world_.entity_manager,
&font_manager_);
scene_lab_->AddComponentToUpdate(
corgi::component_library::TransformComponent::GetComponentId());
scene_lab_->AddComponentToUpdate(ShadowControllerComponent::GetComponentId());
scene_lab_->AddComponentToUpdate(
corgi::component_library::RenderMeshComponent::GetComponentId());
gpg_manager_.Initialize(false);
auto fader_material =
asset_manager_.FindMaterial(asset_manifest.fader_material()->c_str());
assert(fader_material);
fader_.Init(fader_material, shader_textured_);
const Config* config = &GetConfig();
loading_state_.Initialize(&input_, &world_, asset_manifest, &asset_manager_,
&audio_engine_, shader_textured_, &fader_);
pause_state_.Initialize(&input_, &world_, config, &asset_manager_,
&font_manager_, &audio_engine_);
gameplay_state_.Initialize(&input_, &world_, config, &GetInputConfig(),
&world_.entity_manager, scene_lab_.get(),
&gpg_manager_, &audio_engine_, &fader_);
game_menu_state_.Initialize(&input_, &world_, config, &asset_manager_,
&font_manager_, &GetAssetManifest(),
&gpg_manager_, &audio_engine_, &fader_);
game_over_state_.Initialize(&input_, &world_, config, &asset_manager_,
&font_manager_, &gpg_manager_, &audio_engine_);
intro_state_.Initialize(&input_, &world_, config, &fader_, &audio_engine_);
scene_lab_state_.Initialize(&renderer_, &input_, scene_lab_.get(), &world_);
state_machine_.AssignState(kGameStateLoading, &loading_state_);
state_machine_.AssignState(kGameStateGameplay, &gameplay_state_);
state_machine_.AssignState(kGameStatePause, &pause_state_);
state_machine_.AssignState(kGameStateGameMenu, &game_menu_state_);
state_machine_.AssignState(kGameStateIntro, &intro_state_);
state_machine_.AssignState(kGameStateGameOver, &game_over_state_);
state_machine_.AssignState(kGameStateSceneLab, &scene_lab_state_);
state_machine_.SetCurrentStateId(kGameStateLoading);
#ifdef ANDROID_HMD
if (fplbase::AndroidGetActivityName() ==
"com.google.fpl.zooshi.ZooshiHmdActivity") {
world_.SetIsInCardboard(true);
}
#endif // ANDROID_HMD
LogInfo("Initialization complete\n");
return true;
}
void VenomModuleRender(GameMemory* memory) {
RenderState* rs = &memory->renderState;
GameData* data = (GameData*)memory->userdata;
EditorData* editorData = &memory->editor;
EditorData* editor = editorData;
const V3 sunDirection = Normalize(V3(1.0, 0.5, 0.0f));
AddDirectionalLight(sunDirection, V3(1.0, 1.0, 1.0), &rs->drawList);
auto sunModelID = GetModelID("Sun", GetAssetManifest());
auto sunModel = GetModelAsset(sunModelID);
AddStaticModelToDrawList(&rs->drawList, sunModel, sunDirection * 10);
const F32 deltaTime = memory->deltaTime;
EntityContainer* entityContainer = &data->entityContainer;
auto engine = GetEngine();
EntityBlock* block = entityContainer->firstAvaibleBlock;
for (U64 i = 0; i < entityContainer->capacityPerBlock; i++) {
if (block->flags[i] & EntityFlag_PRESENT) {
Entity* entity = &block->entities[i];
if(block->types[i] == EntityType_PointLight) {
AddShadowCastingPointLight(entity->position, entity->pointLight.color,
entity->pointLight.radius, &rs->drawList);
}
ModelAsset *model = GetModelAsset(entity->modelID, &memory->assetManifest);
if (model == nullptr) continue;
bool is_entity_animated = model->jointCount > 0;
if (block->flags[i] & EntityFlag_VISIBLE) {
if (editor->selectedEntities.ContainsValue(i)) {
V3 rotation = QuaternionToEuler(entity->rotation);
AddOutlinedModelToDrawList(&rs->drawList, model, entity->position, rotation);
} else if (is_entity_animated) {
V3 rotation = QuaternionToEuler(entity->rotation);
V3 position = entity->position;
position.y += model->size.y * 0.5f;
AddAnimatedModelToDrawList(&rs->drawList, model, &entity->animation_state, position, rotation);
} else {
V3 rotation = QuaternionToEuler(entity->rotation);
V3 position = entity->position;
position.y += model->size.y * 0.5f;
AddStaticModelToDrawList(&rs->drawList, model, position, rotation);
}
}
}
}
Camera *camera = nullptr;
camera = &data->camera;
#if 0
if (editor->isEditorVisible) {
//camera = &editor->editorCamera;
..draw_debug_camera(&data->camera);
} else {
