Serious-Engine/Sources/Engine/Rendering/RendMisc.cpp

/* Copyright (c) 2002-2012 Croteam Ltd. 
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation


This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */

/////////////////////////////////////////////////////////////////////
// CWorldRenderPrefs

// global instance used in rendering
CWorldRenderPrefs _wrpWorldRenderPrefs;
CBrushSectorSelection *_pselbscVisTweaks = NULL;

/*
 * Constructor -- sets default values.
 */
CWorldRenderPrefs::CWorldRenderPrefs(void)
{
  wrp_bHiddenLinesOn = TRUE;
  wrp_bEditorModelsOn = FALSE;
  wrp_bFieldBrushesOn = FALSE;
  wrp_bShowTargetsOn = FALSE;
  wrp_bShowEntityNames = FALSE;
  wrp_bBackgroundTextureOn = TRUE;
  wrp_bShowVisTweaksOn = FALSE;

  wrp_ftVertices = FT_NONE;
  wrp_colVertices = C_RED;

  wrp_ftEdges = FT_NONE;
  wrp_colEdges = C_BLACK;
                              
  wrp_ftPolygons = FT_TEXTURE;
  wrp_colPolygons = C_WHITE;

  wrp_shtShadows = SHT_FULL;
  wrp_lftLensFlares = LFT_REFLECTIONS_AND_GLARE;

  wrp_abTextureLayers[0] = TRUE;
  wrp_abTextureLayers[1] = TRUE;
  wrp_abTextureLayers[2] = TRUE;

  wrp_fMinimumRenderRange = 5.0f;

  wrp_pmoSelectedEntity = NULL;
  wrp_pmoSelectedPortal = NULL;

  wrp_stSelection = ST_NONE;

  wrp_bAutoMipBrushingOn = TRUE;
  wrp_fManualMipBrushingFactor = 0.0f;
  wrp_bFogOn = TRUE;
  wrp_bHazeOn = TRUE;
  wrp_bMirrorsOn = TRUE;

  wrp_pmoSelectedEntity = NULL;
  wrp_pmoSelectedPortal = NULL;
  wrp_pmoEmptyBrush = NULL;

  wrp_fFarClipPlane=-1.0f;
  wrp_bApplyFarClipPlaneInIsometricProjection=FALSE;
}

// Get mip brushing factor relevant for given distance mip factor
FLOAT CWorldRenderPrefs::GetCurrentMipBrushingFactor(FLOAT fDistanceMipFactor)
{
  // if mip brushing is automatical
  if (wrp_bAutoMipBrushingOn) {
    // use the distance factor
    return fDistanceMipFactor;
  // if mip brushing is manual
  } else {
    // use the manual factor
    return wrp_fManualMipBrushingFactor;
  }
}

/////////////////////////////////////////////////////////////////////
// helper classes
/////////////////////////////////////////////////////////////////////

/* Destructor. */
CScreenPolygon::~CScreenPolygon(void) {
  ASSERT(spo_iInStack == 0);
};

/////////////////////////////////////////////////////////////////////
// CRenderer
/////////////////////////////////////////////////////////////////////
// helper functions

// Coordinate conversion functions
static FLOAT fDiff;
static SLONG slTmp;


static inline PIX PIXCoord(FLOAT f) // (f+0.9999f) or (ceil(f))
{
 #if (defined USE_PORTABLE_C)
  return((PIX) (f+0.9999f));

 #elif (defined __MSVC_INLINE__)
  PIX pixRet;
  __asm {
    fld     dword ptr [f]
    fist    dword ptr [slTmp]
    fisubr  dword ptr [slTmp]
    fstp    dword ptr [fDiff]
    mov     eax,dword ptr [slTmp]
    mov     edx,dword ptr [fDiff]
    add     edx,0x7FFFFFFF
    adc     eax,0
    mov     dword ptr [pixRet],eax
  }
  return pixRet;

 #elif (defined __GNU_INLINE__)
  PIX pixRet;
  __asm__ __volatile__ (
    "flds    (%%eax)              \n\t"
    "fistl   (%%edx)              \n\t"
    "fisubrl (%%edx)              \n\t"
    "fstps   (%%ecx)              \n\t"
    "movl    (%%edx), %%eax       \n\t"
    "movl    (%%ecx), %%edx       \n\t"
    "addl    $0x7FFFFFFF, %%edx   \n\t"
    "adcl    $0, %%eax            \n\t"
        : "=a" (pixRet)
        : "a" (&f), "d" (&slTmp), "c" (&fDiff)
        : "cc", "memory"
  );
  return pixRet;

 #else
  #error Please write inline ASM for your platform.
 #endif
}


static inline PIX PIXCoord(FIX16_16 x) { return (PIX)Ceil(x); };


/*
 * Calculate edge line type depending on whether its polygon is visible or not.
 */
static inline ULONG EdgeLineType(BOOL bPolygonVisible)
{
  // if polygon is visible
  if (bPolygonVisible) {
    // draw all edges with full lines
    return _FULL_;
  // if polygon is not visible
  } else {
    // draw all edges with dashed lines
    return _DOT4_;
  }
}

/*
 * Draw a fat dot used for drawing vertices.
 */
static inline void PutFatPixel(CDrawPort &dp, PIX i, PIX j, COLOR color)
{
  dp.Fill(i-1,j-1, 3,3, color|CT_OPAQUE);
}

/*
 * Draw a more fat dot used for drawing vertices.
 */
static inline void PutMoreFatPixel(CDrawPort &dp, PIX i, PIX j, COLOR color)
{
  dp.Fill(i-1,j-1, 5, 5, color|CT_OPAQUE);
}

/*
 * Draw the most fat dot used for drawing vertices.
 */
static inline void PutTheMostFatPixel(CDrawPort &dp, PIX i, PIX j, COLOR color)
{
  dp.Fill(i-1,j-1, 8,8, color|CT_OPAQUE);
}

/*
 * Draw a line for arrow drawing.
 */
static inline void DrawArrowLine(CDrawPort &dp, const FLOAT2D &vPoint0,
                                 const FLOAT2D &vPoint1, COLOR color, ULONG ulLineType)
{
  PIX x0 = (PIX)vPoint0(1);
  PIX x1 = (PIX)vPoint1(1);
  PIX y0 = (PIX)vPoint0(2);
  PIX y1 = (PIX)vPoint1(2);

  dp.DrawLine(x0, y0, x1, y1, color, ulLineType);
}

/*
 * Draw an arrow for debugging edge directions.
 */
static inline void DrawArrow(CDrawPort &dp, PIX i0, PIX j0, PIX i1, PIX j1, COLOR color,
                             ULONG ulLineType)
{
  FLOAT2D vPoint0 = FLOAT2D((FLOAT)i0, (FLOAT)j0);
  FLOAT2D vPoint1 = FLOAT2D((FLOAT)i1, (FLOAT)j1);
  FLOAT2D vDelta      = vPoint1-vPoint0;
  FLOAT fDelta = vDelta.Length();
  FLOAT2D vArrowLen, vArrowWidth;
  if (fDelta>0.01) {
    vArrowLen   = vDelta/fDelta*FLOAT(10.0);
    vArrowWidth = vDelta/fDelta*FLOAT(2.0);
  } else {
    vArrowWidth = vArrowLen = FLOAT2D(0.0f, 0.0f);
  }
//  FLOAT3D vArrowLen   = vDelta/5.0f;
//  FLOAT3D vArrowWidth = vDelta/30.0f;
  Swap(vArrowWidth(1), vArrowWidth(2));
  //vArrowWidth(2) *= -1.0f;

  DrawArrowLine(dp, vPoint0, vPoint1, color, ulLineType);
  DrawArrowLine(dp, vPoint1-vArrowLen+vArrowWidth, vPoint1, color, ulLineType);
  DrawArrowLine(dp, vPoint1-vArrowLen-vArrowWidth, vPoint1, color, ulLineType);
  //DrawArrowLine(dp, vPoint0+vArrowWidth, vPoint0-vArrowWidth, color, ulLineType);
}


/*
 * Determine color to use for coloring vertices.
 */
inline COLOR CRenderer::ColorForVertices(COLOR colorPolygon, COLOR colorSector)
{
  // check vertices fill type
  switch(_wrpWorldRenderPrefs.wrp_ftVertices) {
  // if it is fixed ink
  case CWorldRenderPrefs::FT_INKCOLOR:
    // use the vertex ink
    return _wrpWorldRenderPrefs.wrp_colVertices;
    break;
  // if it is polygon
  case CWorldRenderPrefs::FT_POLYGONCOLOR:
    // use the polygon color
    return colorPolygon;
    break;
  // if it is sector
  case CWorldRenderPrefs::FT_SECTORCOLOR:
    // use the sector color
    return colorSector;
    break;
  // if it is none
  case CWorldRenderPrefs::FT_NONE:
    // return any color, doesn't matter
    return C_BLACK;
    break;
  // in any other way
  default:
    // error
    ASSERTALWAYS("Invalid fill type for vertices");
    return C_BLACK;
  };
}

/*
 * Determine color to use for coloring edges.
 */
inline COLOR CRenderer::ColorForEdges(COLOR colorPolygon, COLOR colorSector)
{
  // check edges fill type
  switch(_wrpWorldRenderPrefs.wrp_ftEdges) {
  // if it is fixed ink
  case CWorldRenderPrefs::FT_INKCOLOR:
    // use the edge ink
    return _wrpWorldRenderPrefs.wrp_colEdges;
    break;
  // if it is polygon
  case CWorldRenderPrefs::FT_POLYGONCOLOR:
    // use the polygon color
    return colorPolygon;
    break;
  // if it is sector
  case CWorldRenderPrefs::FT_SECTORCOLOR:
    // use the sector color
    return colorSector;
    break;
  // if it is none
  case CWorldRenderPrefs::FT_NONE:
    // return any color, doesn't matter
    return C_BLACK;
    break;
  // in any other way
  default:
    // error
    ASSERTALWAYS("Invalid fill type for edges");
    return C_BLACK;
  };
}

/*
 * Determine color to use for coloring polygons.
 */
inline COLOR CRenderer::ColorForPolygons(COLOR colorPolygon, COLOR colorSector)
{
  // check polygons fill type
  switch(_wrpWorldRenderPrefs.wrp_ftPolygons) {
  // if it is fixed ink
  case CWorldRenderPrefs::FT_INKCOLOR:
    // use the polygon ink
    return _wrpWorldRenderPrefs.wrp_colPolygons;
    break;
  // if it is sector
  case CWorldRenderPrefs::FT_SECTORCOLOR:
    // use the sector color
    return colorSector;
    break;
  // if it is polygon
  case CWorldRenderPrefs::FT_POLYGONCOLOR:
  // or in any other way
  default:
    // use the polygon color
    return colorPolygon;
    break;
  };
}

/*
 * Check if a polygon is selected.
 */
inline BOOL PolygonIsSelected(CBrushPolygon &bpo,
                              CBrush3D &br,
                              CBrushSector &bsc)
{
  // if any selection drawing is active
  if (_wrpWorldRenderPrefs.GetSelectionType() != CWorldRenderPrefs::ST_NONE) {
    // if polygon selection drawing is active and this polygon is selected,
    if ((_wrpWorldRenderPrefs.GetSelectionType() == CWorldRenderPrefs::ST_POLYGONS
         && bpo.IsSelected(BPOF_SELECTED))
    // or sector selection drawing is active and this polygon's sector is selected,
    ||(_wrpWorldRenderPrefs.GetSelectionType() == CWorldRenderPrefs::ST_SECTORS
         && bsc.IsSelected(BSCF_SELECTED))
    // or entity selection drawing is active and this polygon's brush is selected
    ||(_wrpWorldRenderPrefs.GetSelectionType() == CWorldRenderPrefs::ST_ENTITIES
         && (br.br_ulFlags&BRF_DRAWSELECTED))
    ) {
      return TRUE;
    }
  }
  return FALSE;
}

void CRenderer::ProjectClipAndDrawArrow(
  const FLOAT3D &v0, const FLOAT3D &v1, COLOR colColor)
{
  // get transformed end vertices
  FLOAT3D tv0, tv1;
  re_prProjection->PreClip(v0, tv0);
  re_prProjection->PreClip(v1, tv1);

  // clip the edge line
  FLOAT3D vClipped0 = tv0;
  FLOAT3D vClipped1 = tv1;
  ULONG ulClipFlags = re_prProjection->ClipLine(vClipped0, vClipped1);
  // if the edge remains after clipping to front plane
  if (ulClipFlags != LCF_EDGEREMOVED) {
    // project the vertices
    FLOAT3D v3d0, v3d1;
    re_prProjection->PostClip(vClipped0, v3d0);
    re_prProjection->PostClip(vClipped1, v3d1);
    // make 2d vertices
    FLOAT2D v2d0, v2d1;
    v2d0(1) = v3d0(1); v2d0(2) = v3d0(2);
    v2d1(1) = v3d1(1); v2d1(2) = v3d1(2);

    // draw arrow-headed line between vertices
    DrawArrow(*re_pdpDrawPort, (PIX)v2d0(1), (PIX)v2d0(2), 
                             (PIX)v2d1(1), (PIX)v2d1(2), colColor, _FULL_);
  }
}

/*
 * Render target lines for each drawn entity that has some targets.
 */
void CRenderer::RenderEntityTargets(void)
{
  // for each drawn entity
  FOREACHINDYNAMICCONTAINER(re_cenDrawn, CEntity, iten) {
    CEntity &enSource = *iten;

    // if the entity has parent
    if (enSource.en_penParent!=NULL) {
      // draw the arrow from entity to its parent
      ProjectClipAndDrawArrow(
        enSource.GetLerpedPlacement().pl_PositionVector,
        enSource.en_penParent->GetLerpedPlacement().pl_PositionVector,
        C_dBLUE|CT_OPAQUE);
    }

    // for all classes in hierarchy of this entity
    for(CDLLEntityClass *pdecDLLClass = enSource.en_pecClass->ec_pdecDLLClass;
        pdecDLLClass!=NULL; 
        pdecDLLClass = pdecDLLClass->dec_pdecBase) {
      // for all properties
      for(INDEX iProperty=0; iProperty<pdecDLLClass->dec_ctProperties; iProperty++) {
        CEntityProperty &epProperty = pdecDLLClass->dec_aepProperties[iProperty];
        // if the property is not entity pointer
        if( (epProperty.ep_eptType!=CEntityProperty::EPT_ENTITYPTR)||
            (strlen(epProperty.ep_strName)==0) ){
          // skip it
          continue;
        }
        // get the target
        CEntity *penTarget = ENTITYPROPERTY(&enSource, epProperty.ep_slOffset, CEntityPointer);
        // if there is no target
        if (penTarget==NULL) {
          // skip it
          continue;
        }

        // draw the arrow from entity to its target
        ProjectClipAndDrawArrow(
          enSource.GetLerpedPlacement().pl_PositionVector,
          penTarget->GetLerpedPlacement().pl_PositionVector,
          epProperty.ep_colColor);
      }
    }
  }
}

extern CFontData *_pfdConsoleFont;
void CRenderer::RenderEntityNames(void)
{
  // for each of models that were kept for delayed rendering
  for( INDEX iModel=0; iModel<re_admDelayedModels.Count(); iModel++)
  {
    CDelayedModel &dm = re_admDelayedModels[iModel];
    CEntity &en = *dm.dm_penModel;
    CTString strName=en.GetName();
    if( strName=="") continue;
    if( (en.GetRenderType()==CEntity::RT_EDITORMODEL || en.GetRenderType()==CEntity::RT_SKAEDITORMODEL) &&
      !_wrpWorldRenderPrefs.IsEditorModelsOn()) continue;

    FLOATaabbox3D boxModel;
    CModelObject *pmoModelObject;
    CModelInstance *pmiModelInstance;
    // get bounding box of current frame
    if (en.GetRenderType()==CEntity::RT_MODEL || en.GetRenderType()==CEntity::RT_EDITORMODEL) {
      pmoModelObject = dm.dm_pmoModel;
      pmoModelObject->GetCurrentFrameBBox(boxModel);
      if(en.en_pciCollisionInfo!=NULL) {
        // get its collision box
        INDEX iCollision = en.GetCollisionBoxIndex();
        FLOAT3D vMin = pmoModelObject->GetCollisionBoxMin(iCollision);
        FLOAT3D vMax = pmoModelObject->GetCollisionBoxMax(iCollision);
        // extend the box by the collision box
        boxModel|=FLOATaabbox3D(vMin, vMax);
      }
      // set position of marker at top of the model and it size to be proportional to the model
      boxModel.StretchByVector(pmoModelObject->mo_Stretch);
    } else if (en.GetRenderType()==CEntity::RT_SKAMODEL || en.GetRenderType()==CEntity::RT_SKAEDITORMODEL) {
      pmiModelInstance = en.GetModelInstance();
      pmiModelInstance->GetAllFramesBBox(boxModel);
      if(en.en_pciCollisionInfo!=NULL) {  
      // get its collision box
        FLOATaabbox3D box;
        pmiModelInstance->GetCurrentColisionBox(box);
        // extend the box by the collision box
        boxModel|=box;
      }
      boxModel.StretchByVector(pmiModelInstance->mi_vStretch);
    } else {
      continue; 
    }
        
    FLOAT fSize = boxModel.Size().Length()*0.3f;
    _wrpWorldRenderPrefs.wrp_pmoSelectedEntity->mo_Stretch = FLOAT3D( fSize, fSize, fSize);
    CPlacement3D plSelection = en.GetLerpedPlacement();
    plSelection.Translate_OwnSystem( FLOAT3D(0.0f, boxModel.Max()(2), 0.0f));
    FLOAT3D vOrigin=plSelection.pl_PositionVector;
    FLOAT3D vProjected=FLOAT3D(0,0,0);
    re_prProjection->ProjectCoordinate( vOrigin, vProjected);
    if( vProjected(3)>0.0f) continue;
    FLOAT fSizeFactor=1.0f+fSize;
    FLOAT fRatio=Clamp( -vProjected(3)/fSizeFactor, 0.0f, 25.0f);
    FLOAT fPower=CalculateRatio(fRatio, 0, 25.0f, 0, 0.25f);
    if( fPower==0) continue;

    PIX pixH=re_pdpDrawPort->GetHeight();
    re_pdpDrawPort->SetFont( _pfdConsoleFont);
    UBYTE ubAlpha=UBYTE(fPower*255.0f);
    re_pdpDrawPort->PutTextC( strName, (PIX) (vProjected(1)), (PIX) (pixH-vProjected(2)), C_RED|ubAlpha);
  }
}