summaryrefslogblamecommitdiffstats
path: root/src/RendererWorld.cpp
blob: 50d1fcea245fc04602171d46433f753212f717bd (plain) (tree)
1
2
3
4
5
6
7
                            



                                       
                        
                      





                           
                                  
 
                                                     

                                
                                                                                     
                                                                              
                                          
                   
                                       
                                                

                             
                                         
                                       
                                                                                                      
                                       








                                                                                                          
                                                    
                                       
                                                 
                                         
                                                                        

                                     




                                        


                                   








                                                                                                  
                                            
                                   
                                             
                                     
                                                                


                                 



                                                                     
                                                     


                                        
 
 
                                                          
                                                                                                  
 







                                                                            
 
                                 


                               

                                                                                                      
     
                           
 
                               
                                                      

     
                                                         
                                                                                                   


                                                                     
       
 
                                     
                                               
     

 

                                              
                                          

                             
 

                                                 
                    
    

                                                                                     
                             

                                     



                                   

                               
 
                                                                             
                               
                  
                                                 

                                                      
                                  
                                                    
                                                            
                                                

                                    
                                 
                                                                    
                                                                                                       

                                                                        

                             
                                                                
             

                                                                                   
                                   


                                 
    

                                                                               
                                                                   
                                   
                                                                         


             
 

                                                                              
                                                                                                      

                                                                                     







                                                                                     
                                    

                   

                                
 
                                                                                               
                                          
                              

       























                                                                                                              
                                                                            
                                           
       
 

                                                                                  

                               
 

                                                                              






                                     

                                                                                
 
                                              


                                 





                                      
                                                    
                      

                                          

                        
                     

                                  


                                                       

                                                                           



                                                                                  
                                         
                                           
 


















                                                                               

















                                                                             




















                                                                             
















































                                                                                               
 





                                                                             

                                                                                     



                                                                                  

                                     
                         
                                            
                                            
                               









                                              






                                                                     


                      
 




                                                             
        
                                                    
                                 
                             




                                           
                                          

                           


                                     


                                                                               
 
                                                                            
 










                                                                                                                                     
 
 
                                                 
                                                                           
              
                                            
                                
                                                                                               
                                                      

                                                                   


                                                       
 

                                          
              
 
#include "RendererWorld.hpp"

#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#include "DebugInfo.hpp"
#include "Frustum.hpp"
#include "Event.hpp"
#include "AssetManager.hpp"
#include "Renderer.hpp"
#include "Shader.hpp"
#include "GameState.hpp"
#include "Section.hpp"
#include "RendererSectionData.hpp"

void RendererWorld::WorkerFunction(size_t workerId) {
    EventListener tasksListener;

    tasksListener.RegisterHandler("RendererWorkerTask", [&](const Event& eventData) {
		auto data = eventData.get<std::tuple<size_t, Vector, bool>>();
        if (std::get<0>(data) != workerId)
            return;
        Vector vec = std::get<1>(data);
		auto forced = std::get<2>(data);

        sectionsMutex.lock();
        auto result = sections.find(vec);
        if (result != sections.end()) {
            if (result->second.GetHash() != gs->world.GetSection(result->first).GetHash() || forced) {
                sectionsMutex.unlock();
				SectionsData sections;
				sections.section = gs->world.GetSection(vec);
				sections.west = gs->world.GetSection(vec + Vector(1, 0, 0));
				sections.east = gs->world.GetSection(vec + Vector(-1, 0, 0));
				sections.top = gs->world.GetSection(vec + Vector(0, 1, 0));
				sections.bottom = gs->world.GetSection(vec + Vector(0, -1, 0));
				sections.north = gs->world.GetSection(vec + Vector(0, 0, 1));
				sections.south = gs->world.GetSection(vec + Vector(0, 0, -1));
				auto data = std::make_unique<RendererSectionData>(ParseSection(sections));
				data->forced = true;
                renderDataMutex.lock();
                renderData.push(std::move(data));
                renderDataMutex.unlock();
				PUSH_EVENT("NewRenderDataAvailable", 0);
                sectionsMutex.lock();
            }
            else {
                isParsingMutex.lock();
                isParsing[vec] = false;
                isParsingMutex.unlock();
            }                
        }
        else {
            sectionsMutex.unlock();
			SectionsData sections;
			sections.section = gs->world.GetSection(vec);
			sections.west = gs->world.GetSection(vec + Vector(1, 0, 0));
			sections.east = gs->world.GetSection(vec + Vector(-1, 0, 0));
			sections.top = gs->world.GetSection(vec + Vector(0, 1, 0));
			sections.bottom = gs->world.GetSection(vec + Vector(0, -1, 0));
			sections.north = gs->world.GetSection(vec + Vector(0, 0, 1));
			sections.south = gs->world.GetSection(vec + Vector(0, 0, -1));
			auto data = std::make_unique<RendererSectionData>(ParseSection(sections));
			data->forced = true;
            renderDataMutex.lock();
            renderData.push(std::move(data));
            renderDataMutex.unlock();
			PUSH_EVENT("NewRenderDataAvailable", 0);
            sectionsMutex.lock();
        }
        sectionsMutex.unlock();
    });

    LoopExecutionTimeController timer(std::chrono::milliseconds(50));
    while (isRunning) {
        while (tasksListener.NotEmpty() && isRunning)
            tasksListener.HandleEvent();
        timer.Update();
    }
}

void RendererWorld::UpdateAllSections(VectorF playerPos) {
    Vector playerChunk(std::floor(gs->player->pos.x / 16), 0, std::floor(gs->player->pos.z / 16));

    std::vector<Vector> suitableChunks;
    auto chunks = gs->world.GetSectionsList();
    for (auto& it : chunks) {
        double distance = (Vector(it.x, 0, it.z) - playerChunk).GetLength();
        if (distance > MaxRenderingDistance)
            continue;
        suitableChunks.push_back(it);
    }

    std::vector<Vector> toRemove;

    sectionsMutex.lock();
    for (auto& it : sections) {
        if (std::find(suitableChunks.begin(), suitableChunks.end(), it.first) == suitableChunks.end())
            toRemove.push_back(it.first);
    }
    sectionsMutex.unlock();

    for (auto& it : toRemove) {
		PUSH_EVENT("DeleteSectionRender", it);
    }

    playerChunk.y = std::floor(gs->player->pos.y / 16.0);
    std::sort(suitableChunks.begin(), suitableChunks.end(), [playerChunk](Vector lhs, Vector rhs) {
        double leftLengthToPlayer = (playerChunk - lhs).GetLength();
        double rightLengthToPlayer = (playerChunk - rhs).GetLength();
        return leftLengthToPlayer < rightLengthToPlayer;
    });

    for (auto& it : suitableChunks) {
		PUSH_EVENT("ChunkChanged", it);
    }
}

RendererWorld::RendererWorld(GameState* ptr) {
    gs = ptr;
    frustum = std::make_unique<Frustum>();
    MaxRenderingDistance = 2;
    numOfWorkers = 2;

    listener = std::make_unique<EventListener>();

    PrepareRender();
    
    listener->RegisterHandler("DeleteSectionRender", [this](const Event& eventData) {
		auto vec = eventData.get<Vector>();
        sectionsMutex.lock();
        auto it = sections.find(vec);
        if (it == sections.end()) {
            sectionsMutex.unlock();
            return;
        }
        sections.erase(it);
        sectionsMutex.unlock();
    });

    listener->RegisterHandler("NewRenderDataAvailable",[this](const Event&) {
        renderDataMutex.lock();
        int i = 0;
        while (!renderData.empty() && i++ < 20) {
            auto data = std::move(renderData.front());
            renderData.pop();
            isParsingMutex.lock();
            if (isParsing[data->sectionPos] != true)
                LOG(WARNING) << "Generated not parsed data";
            isParsing[data->sectionPos] = false;
            isParsingMutex.unlock();

            sectionsMutex.lock();
            if (sections.find(data->sectionPos) != sections.end()) {
                if (sections.find(data->sectionPos)->second.GetHash() == data->hash && !data->forced) {
                    LOG(INFO) << "Generated not necesarry RendererData";
                    sectionsMutex.unlock();
                    continue;
                }
                sections.erase(sections.find(data->sectionPos));
            }
            RendererSection renderer(*data);
            sections.insert(std::make_pair(data->sectionPos, std::move(renderer)));
            sectionsMutex.unlock();
        }
        renderDataMutex.unlock();
    });
    
    listener->RegisterHandler("EntityChanged", [this](const Event& eventData) {
		auto data = eventData.get<unsigned int>();
        for (unsigned int entityId : gs->world.GetEntitiesList()) {
            if (entityId == data) {
                entities.push_back(RendererEntity(&gs->world, entityId));
            }
        }
    });

    listener->RegisterHandler("ChunkChanged", [this](const Event& eventData) {
		auto vec = eventData.get<Vector>();
        Vector playerChunk(std::floor(gs->player->pos.x / 16), 0, std::floor(gs->player->pos.z / 16));

        double distanceToChunk = (Vector(vec.x, 0, vec.z) - playerChunk).GetLength();
        if (MaxRenderingDistance != 1000 && distanceToChunk > MaxRenderingDistance) {
            return;
        }

        isParsingMutex.lock();
        if (isParsing.find(vec) == isParsing.end())
            isParsing[vec] = false;
        if (isParsing[vec] == true) {
            isParsingMutex.unlock();
            return;
        }
        isParsing[vec] = true;
        isParsingMutex.unlock();

		PUSH_EVENT("RendererWorkerTask", std::make_tuple(currentWorker++, vec, false));
        if (currentWorker >= numOfWorkers)
            currentWorker = 0;
    });

	listener->RegisterHandler("ChunkChangedForce", [this](const Event& eventData) {
		auto vec = eventData.get<Vector>();
		Vector playerChunk(std::floor(gs->player->pos.x / 16), 0, std::floor(gs->player->pos.z / 16));

		double distanceToChunk = (Vector(vec.x, 0, vec.z) - playerChunk).GetLength();
		if (MaxRenderingDistance != 1000 && distanceToChunk > MaxRenderingDistance) {
			return;
		}

		isParsingMutex.lock();
		if (isParsing.find(vec) == isParsing.end())
			isParsing[vec] = false;
		if (isParsing[vec] == true) {
			isParsingMutex.unlock();
			return;
		}
		isParsing[vec] = true;
		isParsingMutex.unlock();

		PUSH_EVENT("RendererWorkerTask", std::make_tuple(currentWorker++, vec, true));
		if (currentWorker >= numOfWorkers)
			currentWorker = 0;
	});

    listener->RegisterHandler("UpdateSectionsRender", [this](const Event&) {
        UpdateAllSections(gs->player->pos);
    });

    listener->RegisterHandler("PlayerPosChanged", [this](const Event& eventData) {
		auto pos = eventData.get<VectorF>();
        UpdateAllSections(pos);
    });

    listener->RegisterHandler("ChunkDeleted", [this](const Event& eventData) {
		auto pos = eventData.get<Vector>();
        sectionsMutex.lock();
        auto it = sections.find(pos);
        if (it != sections.end())
            sections.erase(it);
        sectionsMutex.unlock();
    });

    for (int i = 0; i < numOfWorkers; i++)
        workers.push_back(std::thread(&RendererWorld::WorkerFunction, this, i));

	PUSH_EVENT("UpdateSectionsRender", 0);
}

RendererWorld::~RendererWorld() {
    size_t faces = 0;
    sectionsMutex.lock();
    for (auto& it : sections) {
        faces += it.second.numOfFaces;
    }
    sectionsMutex.unlock();
    LOG(INFO) << "Total faces to render: " << faces;
    isRunning = false;
    for (int i = 0; i < numOfWorkers; i++)
        workers[i].join();
    delete blockShader;
    delete entityShader;
    delete skyShader;
    DebugInfo::renderSections = 0;
    DebugInfo::readyRenderer = 0;
}

void RendererWorld::Render(RenderState & renderState) {
    //Common
    GLint projectionLoc, viewLoc, modelLoc, pvLoc, windowSizeLoc, colorLoc;
    glm::mat4 projection = glm::perspective(
        45.0f, (float) renderState.WindowWidth / (float) renderState.WindowHeight,
        0.1f, 10000000.0f
    );
    glm::mat4 view = gs->GetViewMatrix();
    glm::mat4 projView = projection * view;

    //Render Entities
    glLineWidth(3.0);
    renderState.SetActiveShader(entityShader->Program);
    glCheckError();
    projectionLoc = glGetUniformLocation(entityShader->Program, "projection");
    viewLoc = glGetUniformLocation(entityShader->Program, "view");
    glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));
    glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
    glCheckError();
    modelLoc = glGetUniformLocation(entityShader->Program, "model");
    colorLoc = glGetUniformLocation(entityShader->Program, "color");
    for (auto& it : entities) {
        it.modelLoc = modelLoc;
        it.colorLoc = colorLoc;
        it.Render(renderState);
    }
    glLineWidth(1.0);
    glCheckError();

    //Render selected block
    Vector selectedBlock = gs->selectedBlock;
    if (selectedBlock != Vector()) {
        glLineWidth(2.0f);
        {
            glm::mat4 model;
            model = glm::translate(model, selectedBlock.glm());
            model = glm::translate(model,glm::vec3(0.5f,0.5f,0.5f));
            model = glm::scale(model,glm::vec3(1.01f,1.01f,1.01f));
            glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
            glUniform3f(colorLoc, 0.0, 0.0, 0.0);
            glCheckError();
            glDrawArrays(GL_LINE_STRIP, 0, 36);
        }
        glLineWidth(1.0f);
        glCheckError();
    }

    //Render raycast hit
    bool renderHit = false;
    if (renderHit) {
        VectorF hit = gs->raycastHit;
        glLineWidth(2.0f);
        {
            glm::mat4 model;
            model = glm::translate(model, hit.glm());
            model = glm::scale(model,glm::vec3(0.3f,0.3f,0.3f));
            glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
            if (selectedBlock == Vector())
                glUniform3f(colorLoc,0.7,0.0,0.0);
            else
                glUniform3f(colorLoc, 0.0, 0.0, 0.7);
            glCheckError();
            glDrawArrays(GL_LINE_STRIP, 0, 36);
        }
        glLineWidth(1.0f);
        glCheckError();
    }

	//Render sky
	renderState.TimeOfDay = gs->TimeOfDay;
	renderState.SetActiveShader(skyShader->Program);
	projectionLoc = glGetUniformLocation(skyShader->Program, "projection");
	viewLoc = glGetUniformLocation(skyShader->Program, "view");
	glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));
	glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
	glm::mat4 model = glm::mat4();
	model = glm::translate(model, gs->player->pos.glm());
	const float scale = 1000000.0f;
	model = glm::scale(model, glm::vec3(scale, scale, scale));
	float shift = gs->TimeOfDay / 24000.0f;
	if (shift < 0)
		shift *= -1.0f;
	model = glm::rotate(model, glm::radians(90.0f), glm::vec3(0, 1.0f, 0.0f));
	model = glm::rotate(model, glm::radians(360.0f * shift), glm::vec3(-1.0f, 0.0f, 0.0f));
	modelLoc = glGetUniformLocation(skyShader->Program, "model");
	glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));

	glCheckError();

	const int sunriseMin = 22000;
	const int sunriseMax = 23500;
	const int moonriseMin = 12000;
	const int moonriseMax = 13500;
	const float sunriseLength = sunriseMax - sunriseMin;
	const float moonriseLength = moonriseMax - moonriseMin;

	float mixLevel = 0;
	int dayTime = gs->TimeOfDay;
	if (dayTime < 0)
		dayTime *= -1;
	while (dayTime > 24000)
		dayTime -= 24000;
	if (dayTime > 0 && dayTime < moonriseMin || dayTime > sunriseMax) //day
		mixLevel = 1.0;
	if (dayTime > moonriseMax && dayTime < sunriseMin) //night
		mixLevel = 0.0;
	if (dayTime >= sunriseMin && dayTime <= sunriseMax) //sunrise
		mixLevel = (dayTime - sunriseMin) / sunriseLength;
	if (dayTime >= moonriseMin && dayTime <= moonriseMax) { //moonrise
		float timePassed = (dayTime - moonriseMin);
		mixLevel = 1.0 - (timePassed / moonriseLength);
	}

	glUniform1f(glGetUniformLocation(skyShader->Program, "DayTime"), mixLevel);

	rendererSky.Render(renderState);
	glCheckError();

    //Render sections
    renderState.SetActiveShader(blockShader->Program);
    projectionLoc = glGetUniformLocation(blockShader->Program, "projection");
    viewLoc = glGetUniformLocation(blockShader->Program, "view");
    windowSizeLoc = glGetUniformLocation(blockShader->Program, "windowSize");
    pvLoc = glGetUniformLocation(blockShader->Program, "projView");

	glUniform1f(glGetUniformLocation(blockShader->Program, "DayTime"), mixLevel);
    glUniformMatrix4fv(pvLoc, 1, GL_FALSE, glm::value_ptr(projView));
    glUniform2f(windowSizeLoc, renderState.WindowWidth, renderState.WindowHeight);
    glCheckError();

    frustum->UpdateFrustum(projView);

    sectionsMutex.lock();
    size_t culledSections = sections.size();
    for (auto& section : sections) {        
        sectionsMutex.unlock();
        std::vector<Vector> sectionCorners = {
            Vector(0, 0, 0),
            Vector(0, 0, 16),
            Vector(0, 16, 0),
            Vector(0, 16, 16),
            Vector(16, 0, 0),
            Vector(16, 0, 16),
            Vector(16, 16, 0),
            Vector(16, 16, 16),
        };
        bool isVisible = false;
        for (const auto &it : sectionCorners) {
            VectorF point(section.second.GetPosition().x * 16 + it.x,
                section.second.GetPosition().y * 16 + it.y,
                section.second.GetPosition().z * 16 + it.z);
            if (frustum->TestPoint(point)) {
                isVisible = true;
                break;
            }
        }

        double lengthToSection = (gs->player->pos -
                                  VectorF(section.first.x*16,
                                          section.first.y*16,
                                          section.first.z*16)
                                 ).GetLength();
        
        if (!isVisible && lengthToSection > 30.0f) {
            sectionsMutex.lock();
            culledSections--;
            continue;
        }
        section.second.Render(renderState);
        sectionsMutex.lock();
    }
    this->culledSections = culledSections;
    sectionsMutex.unlock();
    glCheckError();
}

void RendererWorld::PrepareRender() {
    blockShader = new Shader("./shaders/face.vs", "./shaders/face.fs");
    blockShader->Use();
    glUniform1i(glGetUniformLocation(blockShader->Program, "textureAtlas"), 0);

    entityShader = new Shader("./shaders/entity.vs", "./shaders/entity.fs");

    skyShader = new Shader("./shaders/sky.vs", "./shaders/sky.fs");
    skyShader->Use();
    glUniform1i(glGetUniformLocation(skyShader->Program, "textureAtlas"), 0);
    TextureCoordinates skyTexture = AssetManager::Instance().GetTextureByAssetName("minecraft/textures/entity/end_portal");
    glUniform4f(glGetUniformLocation(skyShader->Program, "skyTexture"),skyTexture.x,skyTexture.y,skyTexture.w,skyTexture.h);
    TextureCoordinates sunTexture = AssetManager::Instance().GetTextureByAssetName("minecraft/textures/environment/sun");
    glUniform4f(glGetUniformLocation(skyShader->Program, "sunTexture"), sunTexture.x, sunTexture.y, sunTexture.w, sunTexture.h);
    TextureCoordinates moonTexture = AssetManager::Instance().GetTextureByAssetName("minecraft/textures/environment/moon_phases");
    moonTexture.w /= 4.0f; //First phase will be fine for now
    moonTexture.h /= 2.0f;
    glUniform4f(glGetUniformLocation(skyShader->Program, "moonTexture"), moonTexture.x, moonTexture.y, moonTexture.w, moonTexture.h);
}

void RendererWorld::Update(double timeToUpdate) {
    static auto timeSincePreviousUpdate = std::chrono::steady_clock::now();
    int i = 0;
    while (listener->NotEmpty() && i++ < 50)
        listener->HandleEvent();
    if (std::chrono::steady_clock::now() - timeSincePreviousUpdate > std::chrono::seconds(5)) {
		PUSH_EVENT("UpdateSectionsRender", 0);
        timeSincePreviousUpdate = std::chrono::steady_clock::now();
    }

    DebugInfo::readyRenderer = this->renderData.size();
    DebugInfo::renderSections = this->sections.size();
}

GameState* RendererWorld::GameStatePtr() {
    return gs;
}