eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-21 12:29:18 +02:00
Code Issues 123 Wiki Activity

merge fixes (still broken)

Browse Source
This commit is contained in:
VB
2017-06-28 14:05:05 +02:00
parent 91864d8195
commit f01498facc
11 changed files with 95 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@@ -69,6 +69,7 @@ set(SOURCES
"command.cpp" "command.cpp"
"keyboardinput.cpp" "keyboardinput.cpp"
"gamepadinput.cpp" "gamepadinput.cpp"
"openglgeometrybank.cpp"
) )
if (WIN32) if (WIN32)

7
EU07.cpp
View File

@@ -298,6 +298,13 @@ int main(int argc, char *argv[])
::SendMessage( Hwnd, WM_SETICON, ICON_SMALL, reinterpret_cast<LPARAM>( icon ) ); ::SendMessage( Hwnd, WM_SETICON, ICON_SMALL, reinterpret_cast<LPARAM>( icon ) );
#endif #endif
if ((false == GfxRenderer.Init(window))
|| (false == UILayer.init(window)))
return -1;
input::Keyboard.init();
input::Gamepad.init();
Global::pWorld = &World; // Ra: wskaźnik potrzebny do usuwania pojazdów Global::pWorld = &World; // Ra: wskaźnik potrzebny do usuwania pojazdów
try { try {
if( false == World.Init( window ) ) { if( false == World.Init( window ) ) {

6
Ground.cpp
View File

@@ -522,7 +522,7 @@ TGroundRect::Init() {
- glm::vec3( 500.0f, 0.0f, 500.0f ) // 'upper left' corner of rectangle - glm::vec3( 500.0f, 0.0f, 500.0f ) // 'upper left' corner of rectangle
+ glm::vec3( subrectsize * 0.5f, 0.0f, subrectsize * 0.5f ) // center of sub-rectangle + glm::vec3( subrectsize * 0.5f, 0.0f, subrectsize * 0.5f ) // center of sub-rectangle
+ glm::vec3( subrectsize * column, 0.0f, subrectsize * row ); + glm::vec3( subrectsize * column, 0.0f, subrectsize * row );
area.radius = subrectsize * M_SQRT2; area.radius = subrectsize * (float)M_SQRT2;
// all subcells share the same geometry bank with their parent, to reduce buffer switching during render // all subcells share the same geometry bank with their parent, to reduce buffer switching during render
subcell->m_geometrybank = m_geometrybank; subcell->m_geometrybank = m_geometrybank;
} }
@@ -1365,7 +1365,7 @@ TGroundNode * TGround::AddGroundNode(cParser *parser)
tmp->iType = GL_TRIANGLES; tmp->iType = GL_TRIANGLES;
auto const nv = importedvertices.size(); auto const nv = importedvertices.size();
tmp->Init(nv); // utworzenie tablicy wierzchołków tmp->Init((int)nv); // utworzenie tablicy wierzchołków
for( std::size_t i = 0; i < nv; ++i ) { for( std::size_t i = 0; i < nv; ++i ) {
tmp->pCenter += importedvertices[ i ].position; tmp->pCenter += importedvertices[ i ].position;
@@ -1458,7 +1458,7 @@ TGroundNode * TGround::AddGroundNode(cParser *parser)
auto const nv = importedvertices.size(); auto const nv = importedvertices.size();
tmp->Points = new glm::dvec3[ nv ]; tmp->Points = new glm::dvec3[ nv ];
tmp->iNumPts = nv; tmp->iNumPts = (int)nv;
for( std::size_t i = 0; i < nv; ++i ) { for( std::size_t i = 0; i < nv; ++i ) {
tmp->Points[ i ] = importedvertices[ i ].position; tmp->Points[ i ] = importedvertices[ i ].position;
tmp->pCenter += importedvertices[ i ].position; tmp->pCenter += importedvertices[ i ].position;

16
Model3d.cpp
View File

@@ -1285,13 +1285,13 @@ void TSubModel::serialize(std::ostream &s,
sn_utils::ls_float32(s, fVisible); sn_utils::ls_float32(s, fVisible);
sn_utils::ls_float32(s, fLight); sn_utils::ls_float32(s, fLight);
for (size_t i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
sn_utils::ls_float32(s, f4Ambient[i]); sn_utils::ls_float32(s, f4Ambient[i]);
for (size_t i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
sn_utils::ls_float32(s, f4Diffuse[i]); sn_utils::ls_float32(s, f4Diffuse[i]);
for (size_t i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
sn_utils::ls_float32(s, f4Specular[i]); sn_utils::ls_float32(s, f4Specular[i]);
for (size_t i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
sn_utils::ls_float32(s, f4Emision[i]); sn_utils::ls_float32(s, f4Emision[i]);
sn_utils::ls_float32(s, fWireSize); sn_utils::ls_float32(s, fWireSize);
@@ -1409,13 +1409,13 @@ void TSubModel::deserialize(std::istream &s)
fVisible = sn_utils::ld_float32(s); fVisible = sn_utils::ld_float32(s);
fLight = sn_utils::ld_float32(s); fLight = sn_utils::ld_float32(s);
for (size_t i = 0; i < 4; ++i) for (int i = 0; i < 4; ++i)
f4Ambient[i] = sn_utils::ld_float32(s); f4Ambient[i] = sn_utils::ld_float32(s);
for (size_t i = 0; i < 4; ++i) for (int i = 0; i < 4; ++i)
f4Diffuse[i] = sn_utils::ld_float32(s); f4Diffuse[i] = sn_utils::ld_float32(s);
for (size_t i = 0; i < 4; ++i) for (int i = 0; i < 4; ++i)
f4Specular[i] = sn_utils::ld_float32(s); f4Specular[i] = sn_utils::ld_float32(s);
for (size_t i = 0; i < 4; ++i) for (int i = 0; i < 4; ++i)
f4Emision[i] = sn_utils::ld_float32(s); f4Emision[i] = sn_utils::ld_float32(s);
fWireSize = sn_utils::ld_float32(s); fWireSize = sn_utils::ld_float32(s);

4
Texture.cpp
View File

@@ -890,14 +890,14 @@ texture_manager::find_in_databank( std::string const &Texturename ) const {
auto lookup = m_texturemappings.find( Texturename ); auto lookup = m_texturemappings.find( Texturename );
if( lookup != m_texturemappings.end() ) { if( lookup != m_texturemappings.end() ) {
return lookup->second; return (int)lookup->second;
} }
// jeszcze próba z dodatkową ścieżką // jeszcze próba z dodatkową ścieżką
lookup = m_texturemappings.find( szTexturePath + Texturename ); lookup = m_texturemappings.find( szTexturePath + Texturename );
return ( return (
lookup != m_texturemappings.end() ? lookup != m_texturemappings.end() ?
lookup->second : (int)lookup->second :
npos ); npos );
} }

51
openglgeometrybank.cpp
View File

@@ -122,6 +122,9 @@ opengl_vbogeometrybank::create_( geometry_handle const &Geometry ) {
m_chunkrecords.emplace_back( chunk_record() ); m_chunkrecords.emplace_back( chunk_record() );
// kiss the existing buffer goodbye, new overall data size means we'll be making a new one // kiss the existing buffer goodbye, new overall data size means we'll be making a new one
delete_buffer(); delete_buffer();
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenVertexArrays(1, &m_vao); // TBD: m7todo: maybe vao should be global for all buffers?
} }
// replace() subclass details // replace() subclass details
@@ -142,13 +145,11 @@ opengl_vbogeometrybank::replace_( geometry_handle const &Geometry ) {
// draw() subclass details // draw() subclass details
void void
opengl_vbogeometrybank::draw_( geometry_handle const &Geometry, unsigned int const Streams ) { opengl_vbogeometrybank::draw_( geometry_handle const &Geometry, unsigned int const Streams ) {
if( m_buffer == NULL ) { if( m_buffer == NULL ) {
// if there's no buffer, we'll have to make one // if there's no buffer, we'll have to make one
// NOTE: this isn't exactly optimal in terms of ensuring the gfx card doesn't stall waiting for the data // NOTE: this isn't exactly optimal in terms of ensuring the gfx card doesn't stall waiting for the data
// may be better to initiate upload earlier (during update phase) and trust this effort won't go to waste // may be better to initiate upload earlier (during update phase) and trust this effort won't go to waste
if( true == m_chunks.empty() ) { return; } if( true == m_chunks.empty() ) { return; }
std::size_t datasize{ 0 }; std::size_t datasize{ 0 };
auto chunkiterator = m_chunks.cbegin(); auto chunkiterator = m_chunks.cbegin();
for( auto &chunkrecord : m_chunkrecords ) { for( auto &chunkrecord : m_chunkrecords ) {
@@ -195,23 +196,18 @@ opengl_vbogeometrybank::draw_( geometry_handle const &Geometry, unsigned int con
chunk.vertices.data() ); chunk.vertices.data() );
chunkrecord.is_good = true; chunkrecord.is_good = true;
} }
if( m_activestreams != Streams ) { if( m_activestreams != Streams ) {
bind_streams( Streams ); bind_streams( Streams );
} }
glDebug("D97");
// ...render... // ...render...
::glDrawArrays( chunk.type, chunkrecord.offset, chunkrecord.size ); ::glDrawArrays( chunk.type, (GLint)chunkrecord.offset, (GLsizei)chunkrecord.size );
// ...post-render cleanup // ...post-render cleanup
/*
::glDisableClientState( GL_VERTEX_ARRAY );
::glDisableClientState( GL_NORMAL_ARRAY );
::glDisableClientState( GL_TEXTURE_COORD_ARRAY );
::glBindBuffer( GL_ARRAY_BUFFER, 0 ); m_activebuffer = 0;
*/
} }
void void
opengl_vbogeometrybank::bind_buffer() { opengl_vbogeometrybank::bind_buffer() {
glBindVertexArray(m_vao);
::glBindBuffer( GL_ARRAY_BUFFER, m_buffer ); ::glBindBuffer( GL_ARRAY_BUFFER, m_buffer );
m_activebuffer = m_buffer; m_activebuffer = m_buffer;
m_activestreams = stream::none; m_activestreams = stream::none;
@@ -223,6 +219,7 @@ opengl_vbogeometrybank::delete_buffer() {
if( m_buffer != NULL ) { if( m_buffer != NULL ) {
::glDeleteBuffers( 1, &m_buffer ); ::glDeleteBuffers( 1, &m_buffer );
glBindVertexArray(m_vao);
if( m_activebuffer == m_buffer ) { if( m_activebuffer == m_buffer ) {
m_activebuffer = NULL; m_activebuffer = NULL;
} }
@@ -235,35 +232,36 @@ opengl_vbogeometrybank::delete_buffer() {
void void
opengl_vbogeometrybank::bind_streams( unsigned int const Streams ) { opengl_vbogeometrybank::bind_streams( unsigned int const Streams ) {
if( Streams & stream::position ) { if( Streams & stream::position ) {
::glVertexPointer( 3, GL_FLOAT, sizeof( basic_vertex ), static_cast<char *>( nullptr ) ); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 8, (GLvoid*)0);
::glEnableClientState( GL_VERTEX_ARRAY ); glEnableVertexAttribArray(0);
} }
else { else {
::glDisableClientState( GL_VERTEX_ARRAY ); glDisableVertexAttribArray(0);
} }
// NOTE: normal and color streams share the data, making them effectively mutually exclusive // NOTE: normal and color streams share the data, making them effectively mutually exclusive
if( Streams & stream::normal ) { if( Streams & stream::normal ) {
::glNormalPointer( GL_FLOAT, sizeof( basic_vertex ), static_cast<char *>( nullptr ) + sizeof( float ) * 3 ); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 8, (GLvoid*)(sizeof(float) * 3));
::glEnableClientState( GL_NORMAL_ARRAY ); glEnableVertexAttribArray(1);
} }
else { else {
::glDisableClientState( GL_NORMAL_ARRAY ); glDisableVertexAttribArray(1);
} }
if( Streams & stream::color ) { if( Streams & stream::color ) {
::glColorPointer( 3, GL_FLOAT, sizeof( basic_vertex ), static_cast<char *>( nullptr ) + sizeof( float ) * 3 );
::glEnableClientState( GL_COLOR_ARRAY );
} }
else { else {
::glDisableClientState( GL_COLOR_ARRAY );
} }
if( Streams & stream::texture ) { if( Streams & stream::texture ) {
::glTexCoordPointer( 2, GL_FLOAT, sizeof( basic_vertex ), static_cast<char *>( nullptr ) + 24 ); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 8, (GLvoid*)(sizeof(float) * 6));
::glEnableClientState( GL_TEXTURE_COORD_ARRAY ); glEnableVertexAttribArray(2);
} }
else { else {
::glDisableClientState( GL_TEXTURE_COORD_ARRAY ); glDisableVertexAttribArray(2);
} }
m_activestreams = Streams; m_activestreams = Streams;
@@ -331,10 +329,9 @@ opengl_dlgeometrybank::delete_list( geometry_handle const &Geometry ) {
geometrybank_handle geometrybank_handle
geometrybank_manager::create_bank() { geometrybank_manager::create_bank() {
if( true == Global::bUseVBO ) { m_geometrybanks.emplace_back( std::make_shared<opengl_vbogeometrybank>() ); } m_geometrybanks.emplace_back( std::make_shared<opengl_vbogeometrybank>() );
else { m_geometrybanks.emplace_back( std::make_shared<opengl_dlgeometrybank>() ); }
// NOTE: handle is effectively (index into chunk array + 1) this leaves value of 0 to serve as error/empty handle indication // NOTE: handle is effectively (index into chunk array + 1) this leaves value of 0 to serve as error/empty handle indication
return geometrybank_handle( m_geometrybanks.size(), 0 ); return geometrybank_handle( (uint32_t)m_geometrybanks.size(), 0 );
} }
// creates a new geometry chunk of specified type from supplied vertex data, in specified bank. returns: handle to the chunk or NULL // creates a new geometry chunk of specified type from supplied vertex data, in specified bank. returns: handle to the chunk or NULL

1
openglgeometrybank.h
View File

@@ -190,6 +190,7 @@ private:
static GLuint m_activebuffer; // buffer bound currently on the opengl end, if any static GLuint m_activebuffer; // buffer bound currently on the opengl end, if any
static unsigned int m_activestreams; static unsigned int m_activestreams;
GLuint m_buffer { NULL }; // id of the buffer holding data on the opengl end GLuint m_buffer { NULL }; // id of the buffer holding data on the opengl end
GLuint m_vao = 0;
std::size_t m_buffercapacity{ 0 }; // total capacity of the last established buffer std::size_t m_buffercapacity{ 0 }; // total capacity of the last established buffer
chunkrecord_sequence m_chunkrecords; // helper data for all stored geometry chunks, in matching order chunkrecord_sequence m_chunkrecords; // helper data for all stored geometry chunks, in matching order

112
renderer.cpp
View File

@@ -157,7 +157,6 @@ opengl_renderer::Render() {
// frustum tests are performed in 'world space' but after we set up frustum // frustum tests are performed in 'world space' but after we set up frustum
// we no longer need camera translation, only rotation // we no longer need camera translation, only rotation
::glMultMatrixd( glm::value_ptr( glm::dmat4( glm::dmat3( worldcamera )))); ::glMultMatrixd( glm::value_ptr( glm::dmat4( glm::dmat3( worldcamera ))));
glDisable(GL_FRAMEBUFFER_SRGB); glDisable(GL_FRAMEBUFFER_SRGB);
Render( &World.Environment ); Render( &World.Environment );
glUseProgram(World.shader); glUseProgram(World.shader);
@@ -171,11 +170,10 @@ opengl_renderer::Render() {
m_drawtime = std::max( 20.0f, 0.95f * m_drawtime + std::chrono::duration_cast<std::chrono::milliseconds>( ( std::chrono::steady_clock::now() - timestart ) ).count()); m_drawtime = std::max( 20.0f, 0.95f * m_drawtime + std::chrono::duration_cast<std::chrono::milliseconds>( ( std::chrono::steady_clock::now() - timestart ) ).count());
m_drawcount = m_drawqueue.size(); m_drawcount = m_drawqueue.size();
} }
glDebug("dis1");
glUseProgram(0); glUseProgram(0);
glEnable(GL_FRAMEBUFFER_SRGB); glEnable(GL_FRAMEBUFFER_SRGB);
UILayer.render(); UILayer.render();
glfwSwapBuffers( m_window ); glfwSwapBuffers( m_window );
return true; // for now always succeed return true; // for now always succeed
} }
@@ -204,10 +202,8 @@ opengl_renderer::Render( world_environment *Environment ) {
else { ::glDisable( GL_FOG ); } else { ::glDisable( GL_FOG ); }
Environment->m_skydome.Render(); Environment->m_skydome.Render();
if( true == Global::bUseVBO ) { // skydome uses a custom vbo which could potentially confuse the main geometry system. hardly elegant but, eh
// skydome uses a custom vbo which could potentially confuse the main geometry system. hardly elegant but, eh opengl_vbogeometrybank::reset();
opengl_vbogeometrybank::reset();
}
Environment->m_stars.render(); Environment->m_stars.render();
float const duskfactor = 1.0f - clamp( std::abs( Environment->m_sun.getAngle() ), 0.0f, 12.0f ) / 12.0f; float const duskfactor = 1.0f - clamp( std::abs( Environment->m_sun.getAngle() ), 0.0f, 12.0f ) / 12.0f;
@@ -366,6 +362,8 @@ opengl_renderer::Texture( texture_handle const Texture ) {
bool bool
opengl_renderer::Render( TGround *Ground ) { opengl_renderer::Render( TGround *Ground ) {
World.shader.set_p(OpenGLMatrices.data(GL_PROJECTION));
::glEnable( GL_LIGHTING ); ::glEnable( GL_LIGHTING );
::glDisable( GL_BLEND ); ::glDisable( GL_BLEND );
::glAlphaFunc( GL_GREATER, 0.50f ); // im mniejsza wartość, tym większa ramka, domyślnie 0.1f ::glAlphaFunc( GL_GREATER, 0.50f ); // im mniejsza wartość, tym większa ramka, domyślnie 0.1f
@@ -408,7 +406,9 @@ opengl_renderer::Render( TGround *Ground ) {
} }
if( m_camera.visible( cell->m_area ) ) { if( m_camera.visible( cell->m_area ) ) {
glDebug("to tu?");
Render( cell ); Render( cell );
glDebug("koniec to tu");
} }
} }
} }
@@ -443,7 +443,6 @@ opengl_renderer::Render( TGroundRect *Groundcell ) {
} }
} }
if( Groundcell->nTerrain ) { if( Groundcell->nTerrain ) {
Render( Groundcell->nTerrain ); Render( Groundcell->nTerrain );
} }
Groundcell->iLastDisplay = Groundcell->iFrameNumber; // drugi raz nie potrzeba Groundcell->iLastDisplay = Groundcell->iFrameNumber; // drugi raz nie potrzeba
@@ -506,6 +505,7 @@ opengl_renderer::Render( TGroundNode *Node ) {
/* /*
Node->SetLastUsage( Timer::GetSimulationTime() ); Node->SetLastUsage( Timer::GetSimulationTime() );
*/ */
switch (Node->iType) switch (Node->iType)
{ // obiekty renderowane niezależnie od odległości { // obiekty renderowane niezależnie od odległości
case TP_SUBMODEL: case TP_SUBMODEL:
@@ -524,17 +524,14 @@ opengl_renderer::Render( TGroundNode *Node ) {
return false; return false;
} }
auto const originoffset = Node->m_rootposition - Global::pCameraPosition;
World.shader.set_mv(glm::translate(OpenGLMatrices.data(GL_MODELVIEW), glm::vec3(originoffset.x, originoffset.y, originoffset.z)));
switch (Node->iType) { switch (Node->iType) {
case TP_TRACK: { case TP_TRACK: {
// setup
::glPushMatrix();
auto const originoffset = Node->m_rootposition - Global::pCameraPosition;
::glTranslated( originoffset.x, originoffset.y, originoffset.z );
// render // render
Render( Node->pTrack ); Render( Node->pTrack );
// post-render cleanup
::glPopMatrix();
return true; return true;
} }
@@ -553,23 +550,16 @@ opengl_renderer::Render( TGroundNode *Node ) {
::glColor4fv( ::glColor4fv(
glm::value_ptr( glm::value_ptr(
glm::vec4( glm::vec4(
Node->Diffuse * glm::make_vec3( Global::DayLight.ambient ), Node->Diffuse * Global::daylight.ambient,
std::min( std::min(
1.0, 1.0,
1000.0 * Node->fLineThickness / ( distancesquared + 1.0 ) ) ) ) ); 1000.0 * Node->fLineThickness / ( distancesquared + 1.0 ) ) ) ) );
GfxRenderer.Bind( 0 ); GfxRenderer.Bind( 0 );
::glPushMatrix();
auto const originoffset = Node->m_rootposition - Global::pCameraPosition;
::glTranslated( originoffset.x, originoffset.y, originoffset.z );
// render // render
m_geometry.draw( Node->m_geometry ); m_geometry.draw( Node->m_geometry );
// post-render cleanup
::glPopMatrix();
return true; return true;
} }
@@ -583,16 +573,9 @@ opengl_renderer::Render( TGroundNode *Node ) {
Bind( Node->TextureID ); Bind( Node->TextureID );
::glPushMatrix();
auto const originoffset = Node->m_rootposition - Global::pCameraPosition;
::glTranslated( originoffset.x, originoffset.y, originoffset.z );
// render // render
m_geometry.draw( Node->m_geometry ); m_geometry.draw( Node->m_geometry );
// post-render cleanup
::glPopMatrix();
return true; return true;
} }
@@ -803,7 +786,7 @@ opengl_renderer::Render( TSubModel *Submodel, glm::mat4 m) {
glUseProgram(0); glUseProgram(0);
glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_VERTEX_ARRAY);
glLoadMatrixf(glm::value_ptr(mm)); glLoadMatrixf(glm::value_ptr(mm));
glVertexPointer(3, GL_FLOAT, sizeof(CVertNormTex), static_cast<char *>(nullptr)); // pozycje glVertexPointer(3, GL_FLOAT, sizeof(basic_vertex), static_cast<char *>(nullptr)); // pozycje
// material configuration: // material configuration:
::glPushAttrib( GL_ENABLE_BIT | GL_CURRENT_BIT | GL_COLOR_BUFFER_BIT | GL_POINT_BIT ); ::glPushAttrib( GL_ENABLE_BIT | GL_CURRENT_BIT | GL_COLOR_BUFFER_BIT | GL_POINT_BIT );
@@ -862,7 +845,7 @@ opengl_renderer::Render( TSubModel *Submodel, glm::mat4 m) {
if( Submodel->Next ) if( Submodel->Next )
if( Submodel->iAlpha & Submodel->iFlags & 0x1F000000 ) if( Submodel->iAlpha & Submodel->iFlags & 0x1F000000 )
Render( Submodel->Next ); // dalsze rekurencyjnie Render( Submodel->Next, m ); // dalsze rekurencyjnie
} }
void void
@@ -965,6 +948,9 @@ opengl_renderer::Render_Alpha( TGroundNode *Node ) {
return false; return false;
} }
auto const originoffset = Node->m_rootposition - Global::pCameraPosition;
World.shader.set_mv(glm::translate(OpenGLMatrices.data(GL_MODELVIEW), glm::vec3(originoffset.x, originoffset.y, originoffset.z)));
switch (Node->iType) switch (Node->iType)
{ {
case TP_TRACTION: { case TP_TRACTION: {
@@ -990,16 +976,9 @@ opengl_renderer::Render_Alpha( TGroundNode *Node ) {
Bind( NULL ); Bind( NULL );
::glPushMatrix();
auto const originoffset = Node->m_rootposition - Global::pCameraPosition;
::glTranslated( originoffset.x, originoffset.y, originoffset.z );
// render // render
m_geometry.draw( Node->hvTraction->m_geometry ); m_geometry.draw( Node->hvTraction->m_geometry );
// post-render cleanup
::glPopMatrix();
::glLineWidth( 1.0 ); ::glLineWidth( 1.0 );
if( !Global::bSmoothTraction ) { if( !Global::bSmoothTraction ) {
::glEnable( GL_LINE_SMOOTH ); ::glEnable( GL_LINE_SMOOTH );
@@ -1026,7 +1005,7 @@ opengl_renderer::Render_Alpha( TGroundNode *Node ) {
::glColor4fv( ::glColor4fv(
glm::value_ptr( glm::value_ptr(
glm::vec4( glm::vec4(
Node->Diffuse * glm::make_vec3( Global::DayLight.ambient ), // w zaleznosci od koloru swiatla Node->Diffuse * Global::daylight.ambient, // w zaleznosci od koloru swiatla
std::min( 1.0, linewidth ) ) ) ); std::min( 1.0, linewidth ) ) ) );
if( linewidth > 1.0 ) { if( linewidth > 1.0 ) {
::glLineWidth( static_cast<float>(linewidth) ); ::glLineWidth( static_cast<float>(linewidth) );
@@ -1034,10 +1013,6 @@ opengl_renderer::Render_Alpha( TGroundNode *Node ) {
GfxRenderer.Bind( 0 ); GfxRenderer.Bind( 0 );
::glPushMatrix();
auto const originoffset = Node->m_rootposition - Global::pCameraPosition;
::glTranslated( originoffset.x, originoffset.y, originoffset.z );
// render // render
m_geometry.draw( Node->m_geometry ); m_geometry.draw( Node->m_geometry );
@@ -1046,8 +1021,6 @@ opengl_renderer::Render_Alpha( TGroundNode *Node ) {
::glLineWidth( 1.0f ); ::glLineWidth( 1.0f );
} }
::glPopMatrix();
return true; return true;
} }
@@ -1061,16 +1034,9 @@ opengl_renderer::Render_Alpha( TGroundNode *Node ) {
Bind( Node->TextureID ); Bind( Node->TextureID );
::glPushMatrix();
auto const originoffset = Node->m_rootposition - Global::pCameraPosition;
::glTranslated( originoffset.x, originoffset.y, originoffset.z );
// render // render
m_geometry.draw( Node->m_geometry ); m_geometry.draw( Node->m_geometry );
// post-render cleanup
::glPopMatrix();
return true; return true;
} }
@@ -1209,27 +1175,29 @@ opengl_renderer::Render_Alpha( TSubModel *Submodel, glm::mat4 m) {
World.shader.set_mv(mm); World.shader.set_mv(mm);
} }
if( Submodel->eType < TP_ROTATOR ) { if (Submodel->eType < TP_ROTATOR) {
// renderowanie obiektów OpenGL // renderowanie obiektów OpenGL
if( Submodel->iAlpha & Submodel->iFlags & 0x2F ) // rysuj gdy element przezroczysty if (Submodel->iAlpha & Submodel->iFlags & 0x2F) // rysuj gdy element przezroczysty
{ {
// textures... // textures...
if( Submodel->TextureID < 0 ) { // zmienialne skóry if (Submodel->TextureID < 0) { // zmienialne skóry
Bind( Submodel->ReplacableSkinId[ -Submodel->TextureID ] ); Bind(Submodel->ReplacableSkinId[-Submodel->TextureID]);
} }
else { else {
// również 0 // również 0
Bind( Submodel->TextureID ); Bind(Submodel->TextureID);
} }
::glColor3fv( glm::value_ptr(Submodel->f4Diffuse) ); // McZapkie-240702: zamiast ub ::glColor3fv(glm::value_ptr(Submodel->f4Diffuse)); // McZapkie-240702: zamiast ub
// ...luminance // ...luminance
if( Global::fLuminance < Submodel->fLight ) { if (Global::fLuminance < Submodel->fLight) {
// zeby swiecilo na kolorowo // zeby swiecilo na kolorowo
::glMaterialfv( GL_FRONT, GL_EMISSION, glm::value_ptr(Submodel->f4Diffuse) ); ::glMaterialfv(GL_FRONT, GL_EMISSION, glm::value_ptr(Submodel->f4Diffuse));
} }
// main draw call // main draw call
m_geometry.draw( Submodel->m_geometry ); m_geometry.draw(Submodel->m_geometry);
}
}
else if( Submodel->eType == TP_FREESPOTLIGHT ) { else if( Submodel->eType == TP_FREESPOTLIGHT ) {

13
renderer.h
View File

@@ -78,18 +78,12 @@ public:
Render( TModel3d *Model, material_data const *Material, Math3D::vector3 const &Position, Math3D::vector3 const &Angle ); Render( TModel3d *Model, material_data const *Material, Math3D::vector3 const &Position, Math3D::vector3 const &Angle );
bool bool
Render( TModel3d *Model, material_data const *Material, double const Squaredistance ); Render( TModel3d *Model, material_data const *Material, double const Squaredistance );
void void Render( TSubModel *Submodel );
Render( TSubModel *Submodel );
void Render(TSubModel *Submodel, glm::mat4 m); void Render(TSubModel *Submodel, glm::mat4 m);
void Render_Alpha(TSubModel *Submodel);
void
Render( TMemCell *Memcell );
bool bool
Render_Alpha( TDynamicObject *Dynamic ); Render_Alpha( TDynamicObject *Dynamic );
bool bool
Render_Alpha( TModel3d *Model, material_data const *Material, Math3D::vector3 const &Position, Math3D::vector3 const &Angle ); Render_Alpha( TModel3d *Model, material_data const *Material, Math3D::vector3 const &Position, Math3D::vector3 const &Angle );
void
Render_Alpha( TSubModel *Submodel, glm::mat4 m);
bool bool
Render_Alpha( TModel3d *Model, material_data const *Material, double const Squaredistance ); Render_Alpha( TModel3d *Model, material_data const *Material, double const Squaredistance );
// maintenance jobs // maintenance jobs
@@ -136,6 +130,8 @@ private:
color color
}; };
typedef std::pair<double, TSubRect*> distancesubcell_pair;
// methods // methods
bool bool
Init_caps(); Init_caps();
@@ -161,11 +157,12 @@ private:
Render_Alpha( TGroundNode *Node ); Render_Alpha( TGroundNode *Node );
void void
Render_Alpha( TSubModel *Submodel ); Render_Alpha( TSubModel *Submodel );
void
Render_Alpha(TSubModel *Submodel, glm::mat4 m);
void void
Update_Lights( light_array const &Lights ); Update_Lights( light_array const &Lights );
// members // members
opengllight_array m_lights;
geometrybank_manager m_geometry; geometrybank_manager m_geometry;
texture_manager m_textures; texture_manager m_textures;
opengl_camera m_camera; opengl_camera m_camera;

1
skydome.cpp
View File

@@ -169,6 +169,7 @@ void CSkyDome::Render() {
glDrawElements(GL_TRIANGLES, (GLsizei)m_indices.size(), GL_UNSIGNED_SHORT, 0); glDrawElements(GL_TRIANGLES, (GLsizei)m_indices.size(), GL_UNSIGNED_SHORT, 0);
glBindVertexArray(0); glBindVertexArray(0);
glDebug("dis2");
glUseProgram(0); glUseProgram(0);
} }

3
stars.cpp
View File

@@ -14,6 +14,8 @@ cStars::init() {
void void
cStars::render() { cStars::render() {
//m7todo: restore
/*
// setup // setup
::glPushMatrix(); ::glPushMatrix();
@@ -27,4 +29,5 @@ cStars::render() {
::glPointSize( 3.0f ); ::glPointSize( 3.0f );
::glPopMatrix(); ::glPopMatrix();
*/
} }