/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

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, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/

#include "hsTypes.h"
#include "Max.h"

#include "plRenderInstance.h"

class plNilView : public View 
{
    
public:
    
    Point2 ViewToScreen(Point3 p) { return Point2(p.x,p.y); }
    
    plNilView() 
    {       
        projType = 1;
        fov = hsScalarPI * 0.25f;
        pixelSize = 1.f;
        affineTM.IdentityMatrix();
        worldToView.IdentityMatrix();
        screenW=640.0f; screenH = 480.0f;
    }
    
};

static plNilView nilView;

plRenderInstance::plRenderInstance()
:   fNext(nil),
    fNode(nil),
    fObject(nil),
    fDeleteMesh(false)
{
    mtl = nil;
    mesh = nil;
    flags = 0;
    wireSize = 1.f;
    vis = 1.f;
    nodeID = 0;
    objMotBlurFrame = 0;
    objBlurID = 0;
    objToWorld.IdentityMatrix();
    objToCam.IdentityMatrix();
    normalObjToCam.IdentityMatrix();
    camToObj.IdentityMatrix();
    obBox.Init();
    center = Point3(0,0,0);
    radsq = 0;
}

plRenderInstance::~plRenderInstance()
{
}

void plRenderInstance::Cleanup()
{
    if( mesh && fDeleteMesh )
    {
        mesh->DeleteThis();
        mesh = nil;
        fDeleteMesh = false;
    }
}

BOOL plRenderInstance::Update(TimeValue& t)
{
    fObject = fNode->EvalWorldState(t).obj;
    if( !fObject )
        return false;

    // this shouldn't happen, we shouldn't be trying to make 
    // renderinstances from non GEOMOBJECT's
    if( fObject->SuperClassID() != GEOMOBJECT_CLASS_ID )
        return false;

    if( mesh && fDeleteMesh )
    {
        mesh->DeleteThis();
        mesh = nil;
    }
    fDeleteMesh = false;
    mesh = ((GeomObject*)fObject)->GetRenderMesh(t, fNode, nilView, fDeleteMesh);
    if( !mesh )
        return false;

    vis = fNode->GetVisibility(t);
    if( vis < 0.0f ) 
    {
        vis = 0.0f;
        SetFlag(INST_HIDE, 1);
        return false;
    }
    if (vis > 1.0f) vis = 1.0f;
    SetFlag(INST_HIDE, 0);

    objMotBlurFrame = NO_MOTBLUR;
    objBlurID = 0;

    objToWorld = fNode->GetObjectTM(t);
    objToCam = objToWorld;
    camToObj = Inverse(objToCam);

    normalObjToCam.IdentityMatrix();
    Matrix3 inv = camToObj;
    int i;
    for( i = 0; i < 3; i++ )
        normalObjToCam.SetRow(i, inv.GetColumn3(i));

    obBox = mesh->getBoundingBox(nil);
    center = obBox.Center();
    radsq = LengthSquared(obBox.Width());

    return true;
}

BOOL plRenderInstance::GetFromNode(INode* node, TimeValue& t, int idx)
{
    fNext = nil;

    fValid = Interval(t, t);

    fNode = node;
    mtl = node->GetMtl();
    if( mtl )
    {
        wireSize = mtl->WireSize();
    }

    nodeID = idx;

    ClearLights();

    return Update(t);
}

BOOL plRenderInstance::CastsShadowsFrom(const ObjLightDesc& constLt)
{
    ObjLightDesc& lt = const_cast<ObjLightDesc&>(constLt);
    if( !fNode->CastShadows() )
        return false;

    if( !lt.ls.shadow )
        return false;

    if( lt.GetExclList() && lt.GetExclList()->TestFlag(NT_AFFECT_SHADOWCAST) )
    {
        int idx = lt.GetExclList()->FindNode(fNode);
        BOOL isInc = lt.GetExclList()->TestFlag(NT_INCLUDE); 

        if( idx >= 0 )
        {
            return isInc;
        }
        else
        {
            return !isInc;
        }
    }

    return true;
}

Point3 plRenderInstance::GetFaceNormal(int fnum)
{
    Face* f = &mesh->faces[fnum];
    Point3 a = GetCamVert(f->v[1]) - GetCamVert(f->v[0]);
    Point3 b = GetCamVert(f->v[2]) - GetCamVert(f->v[0]);

    Point3 n = CrossProd(a, b).Normalize();
    return n;
}

Point3 plRenderInstance::GetFaceVertNormal(int fnum, int vertNum)
{
    Point3 retNorm;

    int smGroup=0;

    Face* f = &mesh->faces[fnum];

    // Get the rendered vertex.  Don't use the device position, fPos. 
    RVertex &rv = mesh->getRVert(f->v[vertNum]);

    // Number of normals at the vertex
    int numNormalsAtVert = (rv.rFlags & NORCT_MASK);

    // Specified normal ?
    int specNrml = (rv.rFlags & SPECIFIED_NORMAL);

    if (specNrml || (numNormalsAtVert == 1))
    {
        // The normal case is one normal per vertex (a vertex not beng shared by more than one smoothing group)
        // We'll assign vertex normals here.
        // If the object is faceted, this will be the same as the face normal.
        retNorm = rv.rn.getNormal();
    }
    else
    {
        int found = 0;
        for(int j=0;j<numNormalsAtVert; j++)
        {
            smGroup = rv.ern[j].getSmGroup();
            // Since this vertex is shared by more than one smoothing group, it has multiple normals.
            // This is fairly rare and doesn't occur in faceted objects.
            // Just pick the first normal and use that as the vertex normal.
            int faceSmGroup = f->getSmGroup();
            if ((smGroup & faceSmGroup) == faceSmGroup)
            {
                retNorm = rv.ern[j].getNormal();
                found++;

                // NOTE: Remove this to really check smoothing groups
                break;
            }
        }
    }
    retNorm = retNorm * normalObjToCam;
    retNorm.Normalize();
    return retNorm;
}

Point3 plRenderInstance::GetCamVert(int vertnum)
{
    return objToCam*mesh->verts[vertnum];
}

void plRenderInstance::GetObjVerts(int fnum, Point3 obp[3])
{
    Face* f = &mesh->faces[fnum];
    obp[0] = mesh->verts[f->v[0]];
    obp[1] = mesh->verts[f->v[1]];
    obp[2] = mesh->verts[f->v[2]];
}

void plRenderInstance::GetCamVerts(int fnum, Point3 cp[3])
{
    Face* f = &mesh->faces[fnum];
    cp[0] = objToCam*mesh->verts[f->v[0]];
    cp[1] = objToCam*mesh->verts[f->v[1]];
    cp[2] = objToCam*mesh->verts[f->v[2]];
}

Mtl* plRenderInstance::GetMtl(int fnum)
{
    if( !mtl )
        return nil;

    if( TestFlag(INST_MTL_BYFACE) )
    {
        if( mtl->ClassID() != Class_ID(MULTI_CLASS_ID,0) )
            return mtl;

        Face* f = &mesh->faces[fnum];
        int matIndex = f->getMatID();
        return mtl->GetSubMtl(matIndex);

    }
    else
    {
        return mtl;
    }
}

ULONG plRenderInstance::MtlRequirements(int mtlNum, int faceNum)
{
    if( !mtl )
        return 0;

    if( TestFlag(INST_MTL_BYFACE) )
    {
        Mtl* faceMtl = GetMtl(faceNum);
        return faceMtl ? faceMtl->Requirements(mtlNum) : 0;
    }
    return mtl->Requirements(mtlNum);
}