123

2023-08-07 19:29:24 +08:00
commit 34d6c5d489
4832 changed files with 1389451 additions and 0 deletions
--- a/RenderDll/XRenderOGL/GL_OutSpace.cpp
+++ b/RenderDll/XRenderOGL/GL_OutSpace.cpp
@@ -0,0 +1,353 @@
+#include "RenderPCH.h"
+#include "GL_Renderer.h"
+#include "I3dengine.h"
+
+void CGLRenderer::PrepareOutSpaceTextures(CREOutSpace * pRE)
+{
+  int arrnResult[2];
+  ScanOutSpaceCube(pRE->m_TexID, iSystem->GetViewCamera().GetPos(), arrnResult);
+
+//  vPrevPos[arrnResult[0]] = iSystem->GetViewCamera().GetPos();
+  //vPrevPos[arrnResult[1]] = iSystem->GetViewCamera().GetPos();
+
+/*  
+  int nTempX, nTempY, nTempWidth, nTempHeight;
+  int nTexSize = 512;
+  gRenDev->GetViewport(&nTempX, &nTempY, &nTempWidth, &nTempHeight);
+  gRenDev->SetViewport( 0, 0, nTexSize, nTexSize );
+  
+  I3DEngine * pEngine = iSystem->GetI3DEngine();
+
+  CCamera prevCamera = gRenDev->GetCamera();
+  CCamera tmp_cam = prevCamera;
+
+  tmp_cam.SetAngle(Vec3d(0,0,0));
+  tmp_cam.Init(nTexSize, nTexSize);
+  tmp_cam.Update();  
+
+  iSystem->SetViewCamera(tmp_cam);
+  gRenDev->SetCamera(tmp_cam);
+  pEngine->SetCamera(tmp_cam,false);
+
+  pEngine->DrawLowDetail();
+
+  if(!pRE->m_TexID[0])
+    glGenTextures(1,&(pRE->m_TexID[0]));
+  
+  glBindTexture(GL_TEXTURE_2D, pRE->m_TexID[0]);
+
+  {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+
+    glCopyTexImage2D(
+      GL_TEXTURE_2D,           
+      0,             
+      GL_RGB,
+      0, 0,                 
+      nTexSize, nTexSize,          
+      0);
+  }
+
+  glBindTexture(GL_TEXTURE_2D, 0);
+
+
+  pEngine->SetCamera(prevCamera);
+  iSystem->SetViewCamera(prevCamera);
+  gRenDev->SetCamera(prevCamera);
+
+  gRenDev->SetViewport(nTempX, nTempY, nTempWidth, nTempHeight);
+	glClear(GL_DEPTH_BUFFER_BIT);*/
+}
+
+void CGLRenderer::DrawOutSpaceSide( const float *angle, const Vec3d & Pos, int tex_size, int offsetX, int offsetY)
+{
+  if (!iSystem)
+    return;
+  
+  CRenderer * renderer = gRenDev;
+  CCamera tmp_camera = renderer->GetCamera();
+  CCamera prevCamera = tmp_camera;
+  
+  tmp_camera.Init(tex_size,tex_size);
+  tmp_camera.SetPos(Pos);
+  tmp_camera.SetAngle(Vec3d(angle[0], angle[1], angle[2]));
+  tmp_camera.Update();
+
+  iSystem->SetViewCamera(tmp_camera);
+  gRenDev->SetCamera(tmp_camera);
+
+  gRenDev->SetViewport(tex_size*offsetX, tex_size*offsetY, tex_size, tex_size);
+
+  I3DEngine *eng = (I3DEngine *)iSystem->GetIProcess();
+
+  eng->SetCamera(tmp_camera,false );
+
+  eng->DrawLowDetail(0);
+
+  iSystem->SetViewCamera(prevCamera);
+  gRenDev->SetCamera(prevCamera);
+}
+
+void CGLRenderer::ScanOutSpaceCube(uint & nTexID, const Vec3d & vPos, int * pResult)
+{
+  // get normalized camera angle
+  float fAngle = iSystem->GetViewCamera().GetAngles().z;
+  while(fAngle>360)
+    fAngle-=360;
+  while(fAngle<0)
+    fAngle+=360;
+
+  // get 2 visible sides
+  int nSide = int(fAngle+45)/90;
+  int nSide2 = int(fAngle+45+45)/90;  
+  if(nSide == nSide2)
+    nSide2 = int(fAngle+45-45)/90;
+
+  // normalize
+  if(nSide2<0)
+    nSide2=3;
+  if(nSide2>3)
+    nSide2=0;
+
+  if(nSide<0)
+    nSide=3;
+  if(nSide>3)
+    nSide=0;
+
+  static Vec3d vPrevPos[4];
+
+  // is images valid
+  if (GetDistance(vPrevPos[nSide ],iSystem->GetViewCamera().GetPos())<1.0f &&
+      GetDistance(vPrevPos[nSide2],iSystem->GetViewCamera().GetPos())<1.0f )
+      return; // no need to update
+
+  iLog->Log("nSides = %d, %d",nSide,nSide2);
+
+  // now render 2 cubemap sides
+
+  CRenderer * renderer = gRenDev;
+  int tex_size = 512;
+  while(true)
+  {
+    if (tex_size>renderer->GetWidth() || tex_size>renderer->GetHeight())
+      tex_size >>= 1;
+    else
+      break;
+  }
+  if (tex_size <= 8)
+    return;
+
+  static const GLenum OutSpaceCubeFaces[6] = 
+  {
+    GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT,
+    GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT,
+    GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT,
+    GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT,
+    GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT,
+    GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT,
+  };
+
+  static const float sAngles[6][5] = 
+  {
+    {   0, 180,   0,  0, 0 },
+    {   0, 180,  90,  1, 0 },
+    {   0, 180, 180,  2, 0 },   
+    {   0, 180, 270,  0, 1 },
+    { -90, 180,   0,  1, 1 },
+    {  90, 180,   0,  2, 1 }
+  };
+
+  if(!nTexID)
+  { // create empty if not created
+    glGenTextures(1,&nTexID);
+  assert(nTexID<14000);
+    glBindTexture(GL_TEXTURE_CUBE_MAP_EXT, nTexID);
+    for(int n=0; n<6; n++)
+      glTexImage2D(OutSpaceCubeFaces[n], 0, GL_RGB, tex_size, tex_size, 0, GL_RGB, GL_FLOAT, 0);
+    glBindTexture(GL_TEXTURE_CUBE_MAP_EXT, 0);    
+  }
+
+	glClear(GL_DEPTH_BUFFER_BIT);
+
+  int vX, vY, vWidth, vHeight;
+  gRenDev->GetViewport(&vX, &vY, &vWidth, &vHeight);
+  int bFog=0; // remember fog value
+  glGetIntegerv(GL_FOG,&bFog);
+  m_RP.m_bDrawToTexture = true;
+
+  DrawOutSpaceSide( &sAngles[nSide ][0], vPos, tex_size, 0, 0 );
+  DrawOutSpaceSide( &sAngles[nSide2][0], vPos, tex_size, 1, 0 );
+
+  glBindTexture(GL_TEXTURE_CUBE_MAP_EXT, nTexID);
+  glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_WRAP_R,GL_CLAMP_TO_EDGE);
+  /*
+  int width = tex_size*3;
+  int height = tex_size*2;
+  byte *pic = new byte [width * height * 3];
+  glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, pic);
+  CImage::SaveJPG(pic,FORMAT_24_BIT,width,height,"CubeEnv.jpg"); 
+  delete [] pic;
+    */
+ 
+  glCopyTexSubImage2D(OutSpaceCubeFaces[nSide ], 0, 0, 0, (int)(tex_size*0), (int)(tex_size*0), tex_size, tex_size);
+  glCopyTexSubImage2D(OutSpaceCubeFaces[nSide2], 0, 0, 0, (int)(tex_size*1), (int)(tex_size*0), tex_size, tex_size);
+
+  vPrevPos[nSide] = iSystem->GetViewCamera().GetPos();
+  vPrevPos[nSide2] = iSystem->GetViewCamera().GetPos();
+
+  pResult[0] = nSide;
+  pResult[1] = nSide2;
+
+  gRenDev->SetViewport(vX, vY, vWidth, vHeight);
+
+  glClear(GL_DEPTH_BUFFER_BIT);
+  m_RP.m_bDrawToTexture = false;
+
+  if(bFog)
+    glEnable(GL_FOG);
+}
+
+bool CREOutSpace::mfDraw(SShader *ef, SShaderPass *sfm)
+{    
+  if(!m_TexID)
+    return true;
+
+  gRenDev->ResetToDefault();
+  gRenDev->SetEnviMode(R_MODE_MODULATE);
+  gRenDev->EnableDepthTest(false);
+  gRenDev->EnableDepthWrites(false);
+
+  int bFog=0; // remember fog value
+  glGetIntegerv(GL_FOG,&bFog);
+  glDisable(GL_FOG);
+
+  glBindTexture(GL_TEXTURE_CUBE_MAP_EXT,m_TexID);
+  glEnable(GL_TEXTURE_CUBE_MAP_EXT);
+
+  float scale = 1.f/1;
+  float eyePlaneS[] = { scale, 0, 0, 0 };
+  float eyePlaneT[] = { 0, scale, 0, 0 };
+  float eyePlaneR[] = { 0, 0, scale, 0 };
+
+  glTexGenfv(GL_S, GL_OBJECT_PLANE, eyePlaneS);
+  glTexGenfv(GL_T, GL_OBJECT_PLANE, eyePlaneT);
+  glTexGenfv(GL_R, GL_OBJECT_PLANE, eyePlaneR);
+
+  glTexGenf(GL_S,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
+  glTexGenf(GL_T,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);  
+  glTexGenf(GL_R,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);  
+
+  glEnable(GL_TEXTURE_GEN_S);
+  glEnable(GL_TEXTURE_GEN_T);  
+  glEnable(GL_TEXTURE_GEN_R);  
+
+  glMatrixMode(GL_TEXTURE);
+  glRotatef(-90,1,0,0);
+  glMatrixMode(GL_MODELVIEW);
+
+//  glRotatef(-45,0,0,1);
+
+  float D = 8; // box size
+
+  { // top
+    struct_VERTEX_FORMAT_P3F_TEX2F data[] = 
+    {
+       D,-D, D, 1, 1.f-1,
+      -D,-D, D, 0, 1.f-1,
+       D, D, D, 1, 1.f-0,
+      -D, D, D, 0, 1.f-0,
+    };
+
+//    gRenDev->SetTexture(m_TexID[0]);
+//    gRenDev->SetTexClampMode(true);
+    gRenDev->DrawTriStrip(&(CVertexBuffer (data,VERTEX_FORMAT_P3F_TEX2F)),4);
+  }
+
+  { // s
+    struct_VERTEX_FORMAT_P3F_TEX2F data[] = 
+    { 
+     -D,-D, D, 1.0, 1.f-1.0,
+      D,-D, D, 0.0, 1.f-1.0,
+     -D,-D,-D, 1.0, 1.f-0.0,
+      D,-D,-D, 0.0, 1.f-0.0,
+    };
+
+//    gRenDev->SetTexture(m_TexID[0]);
+//    gRenDev->SetTexClampMode(true);
+    gRenDev->DrawTriStrip(&(CVertexBuffer (data,VERTEX_FORMAT_P3F_TEX2F)),4);
+  }
+  { // e
+    struct_VERTEX_FORMAT_P3F_TEX2F data[] = 
+    { 
+     -D, D, D, 1.0, 1.f-0.0,
+     -D,-D, D, 0.0, 1.f-0.0,
+     -D, D,-D, 1.0, 1.f-0.0,
+     -D,-D,-D, 0.0, 1.f-0.0,
+    };
+
+//    gRenDev->SetTexture(m_TexID[0]);
+//    gRenDev->SetTexClampMode(true);
+    gRenDev->DrawTriStrip(&(CVertexBuffer (data,VERTEX_FORMAT_P3F_TEX2F)),4);
+  }
+  { // n
+    struct_VERTEX_FORMAT_P3F_TEX2F data[] = 
+    { 
+      D, D, D, 1.0, 1.f-1.0,
+     -D, D, D, 0.0, 1.f-1.0,
+      D, D,-D, 1.0, 1.f-0.0,
+     -D, D,-D, 0.0, 1.f-0.0,
+    };
+
+//    gRenDev->SetTexture(m_TexID[0]);
+//    gRenDev->SetTexClampMode(true);
+    gRenDev->DrawTriStrip(&(CVertexBuffer (data,VERTEX_FORMAT_P3F_TEX2F)),4);
+  }
+  { // w
+    struct_VERTEX_FORMAT_P3F_TEX2F data[] = 
+    { 
+      D,-D, D, 1.0, 1.f-0.0,
+      D, D, D, 0.0, 1.f-0.0,
+      D,-D,-D, 1.0, 1.f-0.0,
+      D, D,-D, 0.0, 1.f-0.0,
+    };
+
+//    gRenDev->SetTexture(m_TexID[0]);
+//    gRenDev->SetTexClampMode(true);
+    gRenDev->DrawTriStrip(&(CVertexBuffer (data,VERTEX_FORMAT_P3F_TEX2F)),4);
+  }
+  
+  { // bottom
+    struct_VERTEX_FORMAT_P3F_TEX2F data[] = 
+    {
+       D,-D, -D, 1, 1.f-1,
+      -D,-D, -D, 0, 1.f-1,
+       D, D, -D, 1, 1.f-0,
+      -D, D, -D, 0, 1.f-0,
+    };
+
+//    gRenDev->SetTexture(m_TexID[0]);
+//    gRenDev->SetTexClampMode(true);
+    gRenDev->DrawTriStrip(&(CVertexBuffer (data,VERTEX_FORMAT_P3F_TEX2F)),4);
+  }
+
+  gRenDev->ResetToDefault();
+  gRenDev->ResetTextureMatrix();
+  glDisable(GL_TEXTURE_GEN_S);
+  glDisable(GL_TEXTURE_GEN_T);  
+  glDisable(GL_TEXTURE_GEN_R);  
+  glDisable(GL_TEXTURE_GEN_Q);  
+  glDisable(GL_TEXTURE_CUBE_MAP_EXT);
+
+  if(bFog)
+    glEnable(GL_FOG);
+
+  return true;
+
+}