diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..5bdb3d8 --- /dev/null +++ b/.classpath @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/.project b/.project new file mode 100644 index 0000000..d1ffe54 --- /dev/null +++ b/.project @@ -0,0 +1,33 @@ + + + SLWP + + + + + + com.android.ide.eclipse.adt.ResourceManagerBuilder + + + + + com.android.ide.eclipse.adt.PreCompilerBuilder + + + + + org.eclipse.jdt.core.javabuilder + + + + + com.android.ide.eclipse.adt.ApkBuilder + + + + + + com.android.ide.eclipse.adt.AndroidNature + org.eclipse.jdt.core.javanature + + diff --git a/jni/Android.mk b/jni/Android.mk new file mode 100644 index 0000000..caf8206 --- /dev/null +++ b/jni/Android.mk @@ -0,0 +1,77 @@ +# Copyright (C) 2009 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + + +LPATH := $(call my-dir) + +ENGINE_PATH = $(SalmonEnginePathCygwin) + +BOOST_PATH = $(LibsPathCygwin)/boost_1_52_0 + +OGG_PATH = $(LibsPathCygwin)/libogg-1.3.0 + +VORBIS_PATH = $(LibsPathCygwin)/libvorbis-1.3.2 + +SQUIRREL_PATH = $(LibsPathCygwin)/sqplus + +LIBPNG_PATH = $(LibsPathCygwin)/libpng_1.4.1_android + +ZIP_PATH = $(LibsPathCygwin)/julienr-libzip-android/jni + +#====== ENGINE AND LIBS ===================== + +include $(ENGINE_PATH)/Android_Salmon_Engine.mk + +#================= THE GAME ======================= + + +LOCAL_PATH:= $(LPATH) + +include $(CLEAR_VARS) + +LOCAL_CFLAGS := -DTARGET_ANDROID -DNOSOUND -std=gnu++11 --std=c++11 +LOCAL_STATIC_LIBRARIES := boost +LOCAL_STATIC_LIBRARIES += squirrel +LOCAL_STATIC_LIBRARIES += png_lib +LOCAL_STATIC_LIBRARIES += zip +LOCAL_SHARED_LIBRARIES := SalmonEngine +LOCAL_SHARED_LIBRARIES += gnustl_shared +LOCAL_C_INCLUDES := $(ENGINE_PATH) +LOCAL_C_INCLUDES += $(BOOST_PATH) +LOCAL_C_INCLUDES += $(VORBIS_PATH)/include +LOCAL_C_INCLUDES += $(VORBIS_PATH)/include/vorbis +LOCAL_C_INCLUDES += $(VORBIS_PATH)/lib +LOCAL_C_INCLUDES += $(VORBIS_PATH)/lib/books +LOCAL_C_INCLUDES += $(VORBIS_PATH)/lib/modes +LOCAL_C_INCLUDES += $(OGG_PATH)/include +LOCAL_C_INCLUDES += $(OGG_PATH)/include/ogg +LOCAL_C_INCLUDES += $(SQUIRREL_PATH)/include +LOCAL_C_INCLUDES += $(SQUIRREL_PATH)/sqplus +LOCAL_C_INCLUDES += $(SQUIRREL_PATH)/squirrel +LOCAL_C_INCLUDES += $(SQUIRREL_PATH)/sqstdlib +LOCAL_C_INCLUDES += $(LIBPNG_PATH) +LOCAL_C_INCLUDES += $(ZIP_PATH) +LOCAL_MODULE := SalmonWallpaper +LOCAL_SRC_FILES := main_code.cpp +LOCAL_SRC_FILES += android_api.cpp + +LOCAL_LDLIBS := -lGLESv2 +LOCAL_LDLIBS += -llog -Wl + +#debug +#LOCAL_CFLAGS += -g -ggdb -O0 +#LOCAL_LDLIBS += -g -ggdb + +include $(BUILD_SHARED_LIBRARY) diff --git a/jni/Application.mk b/jni/Application.mk new file mode 100644 index 0000000..b096c4c --- /dev/null +++ b/jni/Application.mk @@ -0,0 +1,3 @@ +APP_STL := gnustl_shared +APP_CPPFLAGS += -fexceptions +APP_CPPFLAGS += -frtti \ No newline at end of file diff --git a/jni/android_api.cpp b/jni/android_api.cpp new file mode 100644 index 0000000..e154036 --- /dev/null +++ b/jni/android_api.cpp @@ -0,0 +1,49 @@ +#include "android_api.h" + +#include "main_code.h" +#include "boost\thread.hpp" + +TAndroidApplication* Application = NULL; + + +float lastOffsetX = 0.5f; + +const float CONST_ANGLE_SHIFT = 45.f; + +int TimeOfDayPref = 0; +bool SnowPref = false; + +bool OffsetChanged = false; + +JNIEXPORT void JNICALL Java_fishrungames_mountainwallpaper_JniWrapper_SetTimeOfDayPref(JNIEnv * env, jobject obj, jint timeofday) +{ + TimeOfDayPref = timeofday; +} +JNIEXPORT void JNICALL Java_fishrungames_mountainwallpaper_JniWrapper_SetSnowPref(JNIEnv * env, jobject obj, jboolean snow) +{ + SnowPref = snow; +} + +JNIEXPORT void JNICALL Java_fishrungames_mountainwallpaper_JniWrapper_Init(JNIEnv * env, jobject obj, jint width, jint height) +{ + + Application = JniInitApp(width, height, 800.f, 480.f); + + boost::get(Renderer->Camera).SetAlpha((lastOffsetX) * pi / 180.f); + Application->SkyTexShift = lastOffsetX*0.01f; + + +} + + +JNIEXPORT void JNICALL Java_fishrungames_mountainwallpaper_JniWrapper_SetOffset(JNIEnv * env, jobject obj, jfloat offsetX, jfloat offsetY) +{ + + if (Renderer != NULL) + { + OffsetChanged = true; + Application->SkyTexShift = offsetX*0.01f; + lastOffsetX = offsetX; + boost::get(Renderer->Camera).SetAlpha((lastOffsetX) * pi / 180.f); + } +} diff --git a/jni/android_api.h b/jni/android_api.h new file mode 100644 index 0000000..117ed80 --- /dev/null +++ b/jni/android_api.h @@ -0,0 +1,30 @@ +#ifndef ANDROID_API_H_INCLUDED +#define ANDROID_API_H_INCLUDED + +#include +#include + +#include +#include +#include + +#include "boost/shared_ptr.hpp" + +#include "main_code.h" + +using namespace SE; + +extern "C" { + + JNIEXPORT void JNICALL Java_fishrungames_mountainwallpaper_JniWrapper_SetTimeOfDayPref(JNIEnv * env, jobject obj, jint timeofday); + + JNIEXPORT void JNICALL Java_fishrungames_mountainwallpaper_JniWrapper_SetSnowPref(JNIEnv * env, jobject obj, jboolean snow); + + JNIEXPORT void JNICALL Java_fishrungames_mountainwallpaper_JniWrapper_Init(JNIEnv * env, jobject obj, jint width, jint height); + + JNIEXPORT void JNICALL Java_fishrungames_mountainwallpaper_JniWrapper_SetOffset(JNIEnv * env, jobject obj, jfloat offsetX, jfloat offsetY); + + }; + + +#endif diff --git a/jni/main_code.cpp b/jni/main_code.cpp new file mode 100644 index 0000000..eda5405 --- /dev/null +++ b/jni/main_code.cpp @@ -0,0 +1,550 @@ +#include "main_code.h" +#ifdef TARGET_ANDROID +#include "android_api.h" +#endif +#include +#include +#include +#include + +#include "include/Engine.h" + +#include "main_code.h" + +bool makeShot = true; + + +extern int TimeOfDayPref; +extern bool SnowPref; + +extern float lastOffsetX; + +#ifdef TARGET_WIN32 +int TimeOfDayPref = 0; +bool SnowPref = false; + +#else +extern int TimeOfDayPref; +extern bool SnowPref; + +#endif + + +boost::mutex m2; + + +class LoadingQueueVisitor : public boost::static_visitor +{ +public: + void operator()(boost::function f) const + { + f(); + } + + void operator()(boost::function f) const + { + f(); + } + + void operator()(boost::function f) const + { + f(); + } +}; + +TAndroidApplication::TAndroidApplication() + : TApplication() + , Inited(false) + , Loaded(false) + , LiteModel(NULL) + , WaterTimer(0) + , SnowTimer(0) + , CloudTimer(0) + , SkyTexShift(0) + , WaveDir(false) +{ +} + + +void TAndroidApplication::Serialize(boost::property_tree::ptree& propertyTree) +{ + BOOST_FOREACH(boost::property_tree::ptree::value_type &v, propertyTree.get_child("Ices")) + { + + std::string modelName = v.second.get("ModelName"); + float posx = v.second.get("PosX"); + float posz = v.second.get("PosZ"); + + float angle = v.second.get("Angle", 0.f); + float scale = v.second.get("Scale", 1.f); + + mat3 m(vec4(0, cos(angle*pi/360.f), 0, sin(angle*pi/360.f))); + + IceModel.push_back(TLiteModel()); + IceModel[IceModel.size()-1].LoadModel(modelName); + IceModel[IceModel.size()-1].RotateModel(m); + IceModel[IceModel.size()-1].ScaleModel(scale); + IceModel[IceModel.size()-1].MoveModel(vec3(posx, 0, posz)); + + + IceModel[IceModel.size()-1].UpdateVBO(); + + + + } +} + + + +void TAndroidApplication::LoadModels() +{ + mat3 m(vec4(0,1*sin(pi/8 + pi/2),0,1*cos(pi/8 + pi/2))); + + LiteModel = new TLiteModel; + LiteModel->LoadModel("mountain.lm1"); + LiteModel->ScaleModel(0.5f); + LiteModel->RotateModel(m); + LiteModel->MoveModel(vec3(0, 0, 0)); + LiteModel->UpdateVBO(); + + std::shared_ptr p = FileToPropertyTree("ices.xml"); + + Serialize(*p); + +} + +void TAndroidApplication::AddFrameBuffers() +{ + ResourceManager->FrameManager.AddFrameRenderBuffer("WaterFrame", 256, 256); + ResourceManager->FrameManager.AddFrameRenderBuffer("ScreenshotFrame", 512, 512); + +} + +void TAndroidApplication::DrawSceneWithoutWater(bool inv) +{ + + + Renderer->PushProjectionMatrix(1,1); + Renderer->LoadIdentity(); + + if (inv) + { + + + if (TimeOfDayPref == 2) + { + glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["sky_night.png"]); + } + else + { + glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["sky.png"]); + } + Renderer->DrawRect(vec2(0.0f, 0.56f), vec2(1.f, 0.f), vec2(0.5f + SkyTexShift, 0.f), vec2(1.f + SkyTexShift, 1.f)); + + if (TimeOfDayPref == 1) + { + glClear(GL_DEPTH_BUFFER_BIT); + glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["final_cloud.png"]); + Renderer->DrawRect(vec2(0.0f, 0.56f), vec2(4.f, 0.f), vec2(0.0f + SkyTexShift + CloudTimer, 0.f), vec2(1.f + SkyTexShift + CloudTimer, 0.5f)); + } + } + else + { + if (TimeOfDayPref == 2) + { + glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["sky_night.png"]); + } + else + { + glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["sky.png"]); + } + Renderer->DrawRect(vec2(0.0f, 0.54f), vec2(1.f, 1.f), vec2(0.5f + SkyTexShift, 0.f), vec2(1.f + SkyTexShift, 1.f)); + + if (TimeOfDayPref == 1) + { + glClear(GL_DEPTH_BUFFER_BIT); + glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["final_cloud.png"]); + Renderer->DrawRect(vec2(0.0f, 0.54f), vec2(4.f, 1.f), vec2(0.0f + SkyTexShift + CloudTimer, 0.f), vec2(1.f + SkyTexShift + CloudTimer, 0.5f)); + } + } + + + + Renderer->PopProjectionMatrix(); + + glClear(GL_DEPTH_BUFFER_BIT); + Renderer->SetGLCamView(); + + if (inv) + { + Renderer->TranslateMatrix(vec3(0,0.1f,0)); + Renderer->ScaleMatrix(vec3(1, -1, 1)); + } + + Renderer->PushShader("SimplelightShader"); + + vec3 dayColor = vec3(0,0,0); + vec3 nightColor = vec3(0, 0.1f, 0.2f); + + if (TimeOfDayPref == 0) + { + RenderUniform3fv("TimeOfDayColor", dayColor.v); + RenderUniform1f("TimeOfDayCoef1", 0.75f); + RenderUniform1f("TimeOfDayCoef2", 0.25f); + } + else + if (TimeOfDayPref == 1) + { + RenderUniform3fv("TimeOfDayColor", dayColor.v); + RenderUniform1f("TimeOfDayCoef1", 0.5f); + RenderUniform1f("TimeOfDayCoef2", 0.25f); + } + else + { + RenderUniform3fv("TimeOfDayColor", nightColor.v); + RenderUniform1f("TimeOfDayCoef1", 0.0f); + RenderUniform1f("TimeOfDayCoef2", 0.4f); + } + + + Renderer->PushPerspectiveProjectionMatrix(pi/6, Renderer->GetMatrixWidth() / Renderer->GetMatrixHeight(), 1.f, 450.f); + + LiteModel->DrawVBO(); + + for (int i=0; iPopProjectionMatrix(); + + Renderer->PopShader(); +} + +void TAndroidApplication::DrawSnow() +{ + + Renderer->PushProjectionMatrix(1,1); + + Renderer->LoadIdentity(); + + const float multiply_x = 4; + const float multiply_y = 2; + + Renderer->DrawRect(vec2(0, 0), vec2(1.f, 1.f), vec2(-SkyTexShift, SnowTimer), vec2(multiply_x - SkyTexShift, multiply_y + SnowTimer)); + glClear(GL_DEPTH_BUFFER_BIT); + Renderer->DrawRect(vec2(0, 0), vec2(1.f, 1.f), vec2(SnowTimer*0.7f+0.3f - SkyTexShift, SnowTimer+0.7f), vec2(multiply_x - SkyTexShift + SnowTimer*0.7f+0.3f, multiply_y + SnowTimer+0.7f)); + glClear(GL_DEPTH_BUFFER_BIT); + Renderer->DrawRect(vec2(0, 0), vec2(1.f, 1.f), vec2(SnowTimer*0.4f+0.7f - SkyTexShift, SnowTimer+0.3f), vec2(multiply_x - SkyTexShift + SnowTimer*0.4f+0.7f, multiply_y + SnowTimer+0.3f)); + + Renderer->PopProjectionMatrix(); +} + +void TAndroidApplication::DrawAllScene(bool toScreen) +{ + glClearColor(0.f, 0.f, 0.f, 1.0f); + //glClearColor(1.f, 1.f, 1.f, 1.0f); + glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); + + Renderer->PushMatrix(); + Renderer->SetGLCamView(); + + Renderer->PushShader("ClipShader"); + + + Renderer->SwitchToFrameBuffer("WaterFrame"); + Renderer->SetGLCamView(); + Renderer->ScaleMatrix(vec3(1, -1, 1)); + + + glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); + + DrawSceneWithoutWater(true); + + Renderer->ScaleMatrix(vec3(1, -1, 1)); + + if (toScreen) + { + Renderer->SwitchToScreen(); + } + else + { + Renderer->SwitchToFrameBuffer("ScreenshotFrame"); + } + + Renderer->SetGLCamView(); + + Renderer->PushShader("NormShader"); + RenderUniform1f("Time", WaterTimer); + if (Renderer->GetScreenWidth() < 600) + { + RenderUniform1f("WaterScale", 0.7f); + } + else + { + RenderUniform1f("WaterScale", 1.f); + } + glActiveTexture(GL_TEXTURE1); + glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["water_nmap.png"]); + glActiveTexture(GL_TEXTURE0); + if (toScreen) + { + Renderer->SetFullScreenViewport(); + } + else + { + Renderer->SetFrameViewport("ScreenshotFrame"); + } + Renderer->DrawFramePartScreen("WaterFrame", vec2(0, 0), vec2(1.f, 0.54f)); + Renderer->PopShader(); + + glClear(GL_DEPTH_BUFFER_BIT); + + Renderer->SetGLCamView(); + + + DrawSceneWithoutWater(false); + + glClear(GL_DEPTH_BUFFER_BIT); + + glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["snow.png"]); + + if (SnowPref) + { + DrawSnow(); + } + + Renderer->PopShader(); + + Renderer->PopMatrix(); +} + +void TAndroidApplication::InnerInit() +{ + m2.lock(); + + CheckGlError(); + + glEnable(GL_BLEND); + + *Console<<"Inner init go!\n"; + +#ifdef TARGET_ANDROID + ResourceManager->PathToResources = ""; +#endif +#ifdef TARGET_WIN32 + ResourceManager->PathToResources = "../../assets/"; +#endif + ResourceManager->ShaderManager.AddShader("DefaultShader", "gui_transparent.vertex", "gui_transparent.fragment"); + Renderer->PushShader("DefaultShader"); + + LoadingQueue.push_back(boost::function(boost::bind(&TShaderManager::AddShader, &(ResourceManager->ShaderManager), "ClipShader", "gui_transparent_clip.vertex", "gui_transparent_clip.fragment"))); + LoadingQueue.push_back(boost::function(boost::bind(&TShaderManager::AddShader, &(ResourceManager->ShaderManager), "NormShader", "test_norm.vertex", "test_norm.fragment"))); + LoadingQueue.push_back(boost::function(boost::bind(&TShaderManager::AddShader, &(ResourceManager->ShaderManager), "ParallaxShader", "test_parallax.vertex", "test_parallax.fragment"))); + LoadingQueue.push_back(boost::function(boost::bind(&TShaderManager::AddShader, &(ResourceManager->ShaderManager), "SimplelightShader", "test_simplelight.vertex", "test_simplelight.fragment"))); + + if (IsFileExistsInUserData("file.bmp")) + { + ResourceManager->TexList.AddTextureFromUserdata("file.bmp", "ScreenshotTexture"); + } + else + { + ResourceManager->TexList.AddTexture("file.bmp", "ScreenshotTexture"); + } + + LoadingQueue.push_back(boost::function(boost::bind(&TTextureListClass::AddTexture, &(ResourceManager->TexList), "console_bkg.bmp", ""))); + LoadingQueue.push_back(boost::function(boost::bind(&TTextureListClass::AddTexture, &(ResourceManager->TexList), "water_nmap.png", ""))); + LoadingQueue.push_back(boost::function(boost::bind(&TTextureListClass::AddTexture, &(ResourceManager->TexList), "sky.png", ""))); + LoadingQueue.push_back(boost::function(boost::bind(&TTextureListClass::AddTexture, &(ResourceManager->TexList), "sky_night.png", ""))); + LoadingQueue.push_back(boost::function(boost::bind(&TTextureListClass::AddTexture, &(ResourceManager->TexList), "snow.png", ""))); + LoadingQueue.push_back(boost::function(boost::bind(&TTextureListClass::AddTexture, &(ResourceManager->TexList), "final_cloud.png", ""))); + + + LoadingQueue.push_back(boost::function(boost::bind(&TModelManager::AddLiteModel, &(ResourceManager->ModelManager), "mountain.lm1", ""))); + LoadingQueue.push_back(boost::function(boost::bind(&TModelManager::AddLiteModel, &(ResourceManager->ModelManager), "ice1.lm1", ""))); + LoadingQueue.push_back(boost::function(boost::bind(&TModelManager::AddLiteModel, &(ResourceManager->ModelManager), "ice2.lm1", ""))); + LoadingQueue.push_back(boost::function(boost::bind(&TModelManager::AddLiteModel, &(ResourceManager->ModelManager), "ice3.lm1", ""))); + LoadingQueue.push_back(boost::function(boost::bind(&TModelManager::AddLiteModel, &(ResourceManager->ModelManager), "ice4.lm1", ""))); + LoadingQueue.push_back(boost::function(boost::bind(&TModelManager::AddLiteModel, &(ResourceManager->ModelManager), "ice5.lm1", ""))); + LoadingQueue.push_back(boost::function(boost::bind(&TModelManager::AddLiteModel, &(ResourceManager->ModelManager), "ice6.lm1", ""))); + + LoadingQueue.push_back(boost::function(boost::bind(&TAndroidApplication::LoadModels, this))); + LoadingQueue.push_back(boost::function(boost::bind(&TAndroidApplication::AddFrameBuffers, this))); + + + + //LoadModels(); + + CheckGlError(); + + + boost::get(Renderer->Camera).MovePhi(pi/32); + + + if (Renderer->GetScreenWidth() > Renderer->GetScreenHeight()) + { + boost::get(Renderer->Camera).MoveDist(30.f); + } + + else + { + boost::get(Renderer->Camera).MoveDist(45.f); + } + + boost::get(Renderer->Camera).CalcCamVec(); + + CheckGlError(); + + ResourceManager->LightManager.SetLightOn(); + + ResourceManager->LightManager.SetLightDirection(vec3(1, -1, 0)); + + //AddFrameBuffers(); + + //Renderer->SetPerspectiveFullScreenViewport(); + + if (Renderer->GetScreenWidth() < Renderer->GetScreenHeight()) + { + Renderer->SetMatrixWidth(480); + Renderer->SetMatrixHeight(800); + } + + Renderer->PushPerspectiveProjectionMatrix(pi/6, Renderer->GetMatrixWidth() / Renderer->GetMatrixHeight(), 1.f, 400.f); + + *Console<<"Inner init end!\n"; + + m2.unlock(); +} + + + +void TAndroidApplication::InnerDeinit() +{ + m2.lock(); + Inited = false; + Loaded = false; + + makeShot = true; + LoadingQueue.clear(); + + if (LiteModel != NULL) + { + LiteModel->FreeModel(); + delete LiteModel; + LiteModel = NULL; + } + + IceModel.clear(); + + SimpleLand = std::shared_ptr(); + SimpleLandInv = std::shared_ptr(); + m2.unlock(); +} + + +void TAndroidApplication::InnerDraw() +{ + m2.lock(); + if (!Loaded) + { + glClearColor(0.f, 0.f, 0.f, 1.0f); + glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); + glBindTexture(GL_TEXTURE_2D, ResourceManager->TexList["ScreenshotTexture"]); + Renderer->PushProjectionMatrix(1,1); + Renderer->LoadIdentity(); + Renderer->DrawRect(vec2(0, 0), vec2(1.f, 1.f)); + Renderer->PopProjectionMatrix(); + + } + else + { + + + DrawAllScene(true); + + if (makeShot) + { + makeShot = false; + + Renderer->SwitchToFrameBuffer("ScreenshotFrame"); + + DrawAllScene(false); + + ResourceManager->TexList.SaveTexDataToPlainBmpToUserData("file.bmp", ResourceManager->FrameManager.ReadFromBufferToTexData("ScreenshotFrame")); + + Renderer->SwitchToScreen(); + + } + } + m2.unlock(); + +} + + +void TAndroidApplication::InnerUpdate(cardinal dt) +{ + + if (!Loaded) + { + + boost::apply_visitor( LoadingQueueVisitor(), *LoadingQueue.begin() ); + LoadingQueue.erase(LoadingQueue.begin()); + + if (LoadingQueue.size() == 0) + { + Loaded = true; + } + } + else + { + + + if (WaveDir) + { + WaterTimer += dt/1000.f; + if (WaterTimer >= 10 * pi) + { + WaveDir = false; + WaterTimer = 10 * pi; + } + } + else + { + WaterTimer -= dt/1000.f; + if (WaterTimer < 0) + { + WaveDir = true; + WaterTimer = 0; + } + } + + CloudTimer += dt / 60000.f; + + while (CloudTimer >= 1.f) + { + CloudTimer -= 1.f; + } + + + SnowTimer += dt/3000.f; + + while (SnowTimer > 10.f) + { + SnowTimer -= 10.f; + } + } + +} + +void TAndroidApplication::InnerOnMove(vec2 shift) +{ + + shift = vec2(shift.v[0]*Renderer->GetMatrixWidth()/static_cast(Renderer->GetScreenWidth()), shift.v[1]*Renderer->GetMatrixHeight()/static_cast(Renderer->GetScreenHeight())); + + boost::get(Renderer->Camera).MoveAlpha(-pi*shift.v[0]*0.1f); +} + +void TAndroidApplication::OnMouseDown(TMouseState& mouseState) +{ + +} \ No newline at end of file diff --git a/jni/main_code.h b/jni/main_code.h new file mode 100644 index 0000000..71494fc --- /dev/null +++ b/jni/main_code.h @@ -0,0 +1,90 @@ +#ifndef GL_CODE_H_INCLUDED +#define GL_CODE_H_INCLUDED + +#ifdef TARGET_ANDROID +//#include "android_api.h" +#endif + +#include +#include +#include + +#ifdef TARGET_ANDROID +#include +#include +#include +#endif + +#include "boost/shared_ptr.hpp" +#include "boost/thread/thread.hpp" +#include "boost/asio.hpp" +#include "boost/signal.hpp" +#include "boost/assign.hpp" +#include "boost/variant.hpp" +#include "boost/function.hpp" +#include "boost/bind.hpp" + +#include "include/Engine.h" + +using namespace SE; + +class TAndroidApplication : public TApplication, public TSerializeInterface +{ +protected: + + void LoadModels(); + void AddFrameBuffers(); + +public: + bool Inited; + bool Loaded; + + std::vector, boost::function, boost::function > > LoadingQueue; + + TLiteModel* LiteModel; + + float WaterTimer; + float SnowTimer; + float CloudTimer; + float SkyTexShift; + bool WaveDir; + + std::vector IceModel; + + std::shared_ptr SimpleLand; + + std::shared_ptr SimpleLandInv; + + TAndroidApplication(); + + virtual void InnerInit(); + + virtual void InnerDeinit(); + + virtual void InnerDraw(); + + virtual void InnerUpdate(cardinal dt); + + virtual void InnerOnMove(vec2 shift); + + virtual void OnMouseDown(TMouseState& mouseState); + + bool IsInited() { return Inited; } + + void DrawSceneWithoutWater(bool inv); + void DrawSnow(); + void DrawAllScene(bool toScreen); + + + virtual void Serialize(boost::property_tree::ptree& propertyTree); + + //void DrawSceneWithoutWaterFrame(); + + +}; + + +//static void checkGlError(const std::string& op); + + +#endif