---

LWSurfaceBlok.cpp

Go to the documentation of this file.

/*
    TEDDY - General graphics application library
    Copyright (C) 1999-2002  Timo Suoranta
    tksuoran@cc.helsinki.fi

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

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    $Id: LWSurfaceBlok.cpp,v 1.4 2002/01/11 14:34:59 tksuoran Exp $
*/


#include "Teddy/TeddyConfig.h"
#if defined( TEDDY_INCLUDE_LW_SCENE )


#include "Teddy/Imports/LWFile.h"
#include "Teddy/Imports/LWLayer.h"
#include "Teddy/Imports/LWModel.h"
#include "Teddy/Imports/LWSurface.h"
#include "Teddy/Imports/LWSurfaceBlok.h"
#include "Teddy/SysSupport/Messages.h"
#include "Teddy/SysSupport/StdIO.h"
using namespace Teddy::SysSupport;


namespace Teddy   {
namespace Imports {


LWSurfaceBlok::LWSurfaceBlok( LWSurface *surface ){
    this->f       = surface->getLayer()->getModel()->getFile();
    this->surface = surface;
    texture_channel    = 0;
    enable             = 0;
    opacity_type       = 0;
    opacity            = 0;
    opacity_envelope   = 0;
    displacement_axis  = 0;

    texture_center                        = Vector(0,0,0);
    texture_center_envelope               = 0;
    texture_size                          = Vector(1,1,1);
    texture_size_envelope                 = 0;
    texture_rotation                      = Vector(0,0,0);
    texture_rotation_envelope             = 0;
    texture_falloff_type                  = 0;
    texture_falloff                       = Vector(0,0,0);
    texture_falloff_envelope              = 0;
    texture_coordinate_system             = 0;

    texture_projection_mode               = 0;
    texture_major_axis                    = 0;
    texture_image_map                     = 0;
    texture_width_wrap                    = 0;
    texture_height_wrap                   = 0;
    texture_wrap_width_cycles             = 0;
    texture_wrap_width_cycles_envelope    = 0;
    texture_wrap_height_cycles            = 0;
    texture_wrap_height_cycles_envelope   = 0;
    texture_antialiasing_type             = 0;
    texture_antialiasing_strength         = 0;
    texture_pixel_blending                = 0;
    texture_stack                         = 0;
    texture_amplitude                     = 0;
    texture_amplitude_envelope            = 0;
    texture_negative                      = 0;
    procedural_axis       = 0;
    gradient_range_start  = 0;
    gradient_range_end    = 0;
    gradient_repeat       = 0;
}


void LWSurfaceBlok::processBlok(){
    ID4  blok_type    = f->read_ID4();
    ID4  blok_ordinal = f->read_ID4();
    bool header_done  = false;
    ID4  subchunk;
    U2   length;

    while( f->domainLeft() > 0 ){

        subchunk = f->read_ID4();
        length   = f->read_U2();
        f->pushDomain( length );

        dmsg( M_LWO,
            "LWO2::SURF::BLOK::%s::%s (%d bytes)",
            did( blok_type ),
            did( subchunk  ),
            length
        );

        //  Headers are accepted only in the beginning
        if( header_done == false ){
            switch( subchunk ){
            case ID_CHAN: readChannel_ID4        (); break;
            case ID_ENAB: readEnable_U2          (); break;
            case ID_OPAC: readOpacity_U2_FP4_VX  (); break;
            case ID_AXIS: readDisplacementAxis_U2(); break;
            default:      header_done = true;        break;
            }
        }

        //  Other than headers
        if( header_done == true ){
            //  LWO2 BLOK Block Headers
            //  
            //  Every block contains a header subchunk.
            //  
            //  block-header { ordinal[S0], block-attributes[SUB-CHUNK] * } 
            //  
            //  The ID of the header subchunk identifies the block type and can
            //  be one of the following.
            //  
            //  IMAP - an image map texture
            //  PROC - a procedural texture
            //  GRAD - a gradient texture
            //  SHDR - a shader plug-in
            //  
            //  The header contains an ordinal string (described above) and
            //  subchunks that are common to all block types. 
            switch( blok_type ){
            //  LWO2 BLOK Image Maps
            //  
            //  Texture blocks with a header type of IMAP are image maps.
            //  These use an image to modulate one of the surface channels.
            //  In addition to the basic parameters listed below, the block
            //  may also contain a TMAP chunk. 
            //
            case ID_IMAP:
                switch( subchunk ){
                case ID_TMAP: readTextureMap               ( ID_IMAP ); break;
                case ID_PROJ: readTextureProjectionMode_U2          (); break;
                case ID_AXIS: readTextureMajorAxis_U2               (); break;
                case ID_IMAG: readTextureImageMap_VX                (); break;
                case ID_WRAP: readTextureWrapOptions_U2_U2          (); break;
                case ID_WRPW: readTextureWrapWidthAmount_FP4_VX     (); break;
                case ID_WRPH: readTextureWrapHeightAmount_FP4_VX    (); break;
                case ID_VMAP: readTextureUV_VertexMap_S0            (); break;
                case ID_AAST: readTextureAntialiasingStrength_U2_FP4(); break;
                case ID_PIXB: readTexturePixelBlending_U2           (); break;
                case ID_STCK: readTextureStack_VX                   (); break;
                case ID_TAMP: readTextureAmplitude_FP4_VX           (); break;
                case ID_NEGA: readTextureNegative_U2                (); break;

                //  New block state?
                default:
                    dmsg( M_LWO, "FIX End IMAP, to %s", did(subchunk) );
                    applyAttributes( blok_type );
                    blok_type = subchunk;
                    break;
                }
                break;  //  ID_IMAP

            //  LWO2 BLOK Procedural Textures
            //  
            //  Texture blocks of type PROC are procedural textures
            //  that modulate the value of a surface channel
            //  algorithmically. 
            //  
            case ID_PROC:
                switch( subchunk ){
                case ID_TMAP: readTextureMap            ( ID_PROC ); break;
                case ID_AXIS: readProceduralAxis_U2              (); break;
                case ID_VALU: readProceduralBasicValue_FP4_1_or_3(); break;
                case ID_FUNC: readProceduralAlgorithm_S0_data    (); break;
                                                                  
                //  New block state?
                default:
                    dmsg( M_LWO, "FIX End PROC, to %s", did(subchunk) );
                    applyAttributes( blok_type );
                    blok_type = subchunk;
                    break;
                }
                break;  //  ID_PROC

            //  Gradient Textures
            //  
            //  Texture blocks of type GRAD are gradient textures that
            //  modify a surface channel by mapping an input parameter
            //  through an arbitrary transfer function. Gradients are
            //  represented to the user as a line containing keys. Each
            //  key is a color, and the gradient function is an interpolation
            //  of the keys in RGB space. The input parameter selects a
            //  point on the line, and the output of the texture is the
            //  value of the gradient at that point. 
            //  
            case ID_GRAD:
                switch( subchunk ){
                case ID_PNAM: readGradientParameter_S0           (); break;
                case ID_INAM: readGradientItem_S0                (); break;
                case ID_GRST: readGradientRangeStart_FP4         (); break;
                case ID_GREN: readGradientRangeEnd_FP4           (); break;
                case ID_GRPT: readGradientRepeat_U2              (); break;
                case ID_FKEY: readGradientKeys_FP4_data_FP4      (); break;
                case ID_IKEY: readGradientKeyParameters_data_U2  (); break;

                //  New blok state?
                default:
                    dmsg( M_LWO, "FIX End GRAD, to %s", did(subchunk) );
                    applyAttributes( blok_type );
                    blok_type = subchunk;
                    break;
                }
                break;  //  ID_GRAD

            //  LWO2 BLOK Shaders
            //  
            //  Shaders are BLOK subchunks with a header type
            //  of SHDR. They are applied to a surface after
            //  all basic channels and texture layers are
            //  evaluated, and in the order specified by the
            //  ordinal sequence. The only header chunk they
            //  support is ENAB and they need only one data
            //  chunk to describe them. 
            //  
            case ID_SHDR:
                switch( subchunk ){
                case ID_FUNC: readShaderAlgorithm_S0_data        (); break;

                //  New blok state?
                default:
                    dmsg( M_LWO, "FIX End SHDR, to %s", did(subchunk) );
                    applyAttributes( blok_type );
                    blok_type = subchunk;
                    break;
                }
                break;  //  ID_SHDR

            //  Unknown attribute -- blok_state
            default:
                dmsg( M_LWO,
                    "LWO2::SURF::BLOK parser confused by blok type %s",
                    did(blok_type)
                );
                break;
            }
        }

        f->popDomain( true );
    }
    applyAttributes( blok_type );
}


void LWSurfaceBlok::applyAttributes( ID4 type ){
    switch( type ){
    case ID_IMAP: applyImageMap  (); break;
    case ID_PROC: applyProcedural(); break;
    case ID_GRAD: applyGradient  (); break;
    case ID_SHDR: applyShader    (); break;
    default:
        dmsg( M_LWO, "Unknown BLOK attribute %s", type );
        break;
    }
}


void LWSurfaceBlok::readTextureMap( ID4 parent ){
    ID4  subchunk;
    U2   length;

    while( f->domainLeft() > 0 ){

        subchunk = f->read_ID4();
        length   = f->read_U2();

        dmsg( M_LWO,
            "LWO2::SURF::BLOK::%s::TMAP::%s (%d bytes)",
            did( parent   ),
            did( subchunk ),
            length
        );

        f->pushDomain( length );
        switch( subchunk ){
        case ID_CNTR: readTextureCenter_VEC12_VX            (); break;
        case ID_SIZE: readTextureSize_VEC12_VX              (); break;
        case ID_ROTA: readTextureRotation_VEC12_VX          (); break;
        case ID_OREF: readTextureReferenceObject_S0         (); break;
        case ID_FALL: readTextureFalloff_U2_VEC12_VX        (); break;
        case ID_CSYS: readTextureCoordinateSystem_U2        (); break;

        //  New blok state?
        default: 
            dmsg( M_LWO, "Unknown TMAP::%s", did(subchunk) );
            break;
        }
        f->popDomain( true );
    }
}


void LWSurfaceBlok::readChannel_ID4(){
    texture_channel = f->read_ID4();
}


void LWSurfaceBlok::readEnable_U2(){
    enable = f->read_U2();
}


void LWSurfaceBlok::readOpacity_U2_FP4_VX(){
    opacity_type     = f->read_U2 ();
    opacity          = f->read_FP4();
    opacity_envelope = f->read_VX ();  //  FIX envelope
}


void LWSurfaceBlok::readDisplacementAxis_U2(){
    displacement_axis = f->read_U2();
}


void LWSurfaceBlok::readTextureCenter_VEC12_VX(){
    texture_center          = f->read_VEC12();
    texture_center_envelope = f->read_VX   ();  //  FIX envelope
}


void LWSurfaceBlok::readTextureSize_VEC12_VX(){
    texture_size          = f->read_VEC12();
    texture_size_envelope = f->read_VX   ();  //  FIX envelope
}

void LWSurfaceBlok::readTextureRotation_VEC12_VX(){
    texture_rotation          = f->read_VEC12();
    texture_rotation_envelope = f->read_VX   ();  //  FIX envelope
}


void LWSurfaceBlok::readTextureReferenceObject_S0(){
    texture_reference_object = f->read_S0();
}


void LWSurfaceBlok::readTextureFalloff_U2_VEC12_VX(){
    texture_falloff_type     = f->read_U2   ();
    texture_falloff          = f->read_VEC12();
    texture_falloff_envelope = f->read_VX   ();  //  FIX envelope
}


void LWSurfaceBlok::readTextureCoordinateSystem_U2(){
    texture_coordinate_system = f->read_U2();
}


void LWSurfaceBlok::readTextureProjectionMode_U2(){
    texture_projection_mode = f->read_U2();
}


void LWSurfaceBlok::readTextureMajorAxis_U2(){
    texture_major_axis = f->read_U2();
}


void LWSurfaceBlok::readTextureImageMap_VX(){
    texture_image_map = f->read_VX();
}


void LWSurfaceBlok::readTextureWrapOptions_U2_U2(){
    texture_width_wrap  = f->read_U2();
    texture_height_wrap = f->read_U2();
}


void LWSurfaceBlok::readTextureWrapWidthAmount_FP4_VX(){
    texture_wrap_width_cycles          = f->read_FP4();
    texture_wrap_width_cycles_envelope = f->read_VX ();  //  FIX envelope
}


void LWSurfaceBlok::readTextureWrapHeightAmount_FP4_VX(){
    texture_wrap_height_cycles          = f->read_FP4();
    texture_wrap_height_cycles_envelope = f->read_VX ();  //  FIX envelope
}


void LWSurfaceBlok::readTextureUV_VertexMap_S0(){
    texture_uv_vertex_map = f->read_S0();
}


void LWSurfaceBlok::readTextureAntialiasingStrength_U2_FP4(){
    texture_antialiasing_type     = f->read_U2 ();
    texture_antialiasing_strength = f->read_FP4();
}


void LWSurfaceBlok::readTexturePixelBlending_U2(){
    texture_pixel_blending = f->read_U2();
}


void LWSurfaceBlok::readTextureStack_VX(){
    texture_stack = f->read_VX();  //  FIX envelope
}


void LWSurfaceBlok::readTextureAmplitude_FP4_VX(){
    texture_amplitude          = f->read_FP4();
    texture_amplitude_envelope = f->read_VX ();  //  FIX envelope
}


void LWSurfaceBlok::readTextureNegative_U2(){
    texture_negative = f->read_U2();
}


void LWSurfaceBlok::readProceduralAxis_U2(){
    procedural_axis = f->read_U2();
}

void LWSurfaceBlok::readProceduralBasicValue_FP4_1_or_3(){
    //lwo_debug_msg( "# (1, 3)" );
}


void LWSurfaceBlok::readProceduralAlgorithm_S0_data(){
    procedural_algorithm = f->read_S0();
    //lwo_debug_msg( "data[...]" );
}


void LWSurfaceBlok::readGradientParameter_S0(){
    gradient_parameter = f->read_S0();
}


void LWSurfaceBlok::readGradientItem_S0(){
    gradient_item = f->read_S0();
}


void LWSurfaceBlok::readGradientRangeStart_FP4(){
    gradient_range_start = f->read_FP4();
}

void LWSurfaceBlok::readGradientRangeEnd_FP4(){
    gradient_range_end = f->read_FP4();
}


void LWSurfaceBlok::readGradientRepeat_U2(){
    gradient_repeat = f->read_U2();
}


void LWSurfaceBlok::readGradientKeys_FP4_data_FP4(){
    //lwo_debug_msg( "FKEY { ( input[FP4], output[FP4] # 4 )* }" );
}


void LWSurfaceBlok::readGradientKeyParameters_data_U2(){
    //lwo_debug_msg( "IKEY { interpolation[U2] * }" );
}


void LWSurfaceBlok::readShaderAlgorithm_S0_data(){
    shader_algorithm = f->read_S0();
    //lwo_debug_msg( "FUNC { algorithm-name[S0], data[...] }" );
}


};  //  namespace Imports
};  //  namespace Teddy


#endif  //  TEDDY_INCLUDE_LW_SCENE