---

LWSurface.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: LWSurface.cpp,v 1.4 2002/01/11 14:34:59 tksuoran Exp $
*/


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


#include "Teddy/Graphics/Color.h"
#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/Imports/LWTexture.h"
#include "Teddy/SysSupport/Messages.h"
#include "Teddy/SysSupport/StdMaths.h"
#include <cstring>
using namespace Teddy::Graphics;
using namespace Teddy::SysSupport;


namespace Teddy   {
namespace Imports {


char *LWSurface::LW_ImageMapStrings[] = {
    "Planar Image Map",
    "Cylindrical Image Map",
    "Spherical Image Map",
    "Cubic Image Map",
};

/*
#define LW_PLANAR_IMAGE_MAP      1
#define LW_CYLINDRICAL_IMAGE_MAP 2
#define LW_SPHERICAL_IMAGE_MAP   3
#define LW_CUBIC_IMAGE_MAP       4
*/

int LWSurface::getMapType( const char *s ){
    int type = 0;

    if( strcmp( s, "Planar Image Map"      ) == 0 ) type = LW_PLANAR_IMAGE_MAP;
    if( strcmp( s, "Cylindrical Image Map" ) == 0 ) type = LW_CYLINDRICAL_IMAGE_MAP;
    if( strcmp( s, "Spherical Image Map"   ) == 0 ) type = LW_SPHERICAL_IMAGE_MAP;
    if( strcmp( s, "Cubic Image Map"       ) == 0 ) type = LW_CUBIC_IMAGE_MAP;

    return type;
}


LWSurface::LWSurface( LWLayer *layer, Model *model, const std::string &name )
:Material(
    name,
    RENDER_MODE_FILL/*_OUTLINE*/,
    RENDER_LIGHTING_SIMPLE,
//  RENDER_LIGHTING_COLOR,
    RENDER_OPTION_CULL_FACE_M  |
    RENDER_OPTION_DEPTH_TEST_M |
    RENDER_OPTION_AMBIENT_M    |
    RENDER_OPTION_DIFFUSE_M    |
    RENDER_OPTION_SPECULAR_M   |
    RENDER_OPTION_EMISSION_M   |
    RENDER_OPTION_SHINYNESS_M 
//  RENDER_OPTION_BORDER_M
//  RENDER_OPTION_SMOOTH_M
){
    Color lwdef = Color( 200.0f/255.0f, 200.0f/255.0f, 200.0f/255.0f );
    setEmission( Color::BLACK   );
    setAmbient ( lwdef );
    setDiffuse ( lwdef );
    setSpecular( Color::GRAY_25 );
    setBorder  ( Color::WHITE   );
    this->f             = layer->getModel()->getFile();
    this->layer         = layer;
    this->model         = model;
    baseColor           = Color::WHITE;
    luminosity_p        = 0.00f; // emission
    diffuse_p           = 1.00f;
    specular_p          = 0.25f; 
    reflection_p        = 0;
    transparency_p      = 0;
    translucency_p      = 0;
    shininess           = shininess = pow( 2, (10.0f * 0.40f) + 2 );
    current_texture     = NULL;
    max_smoothing_angle = 0;
    //lwo_debug_msg( "Surface %s", name );
    dmsg( M_LWS, "Surface %s", name.c_str() );
}


/*virtual*/ LWSurface::~LWSurface(){
    //  FIX
}


LWLayer *LWSurface::getLayer(){
    return layer;
}

Model *LWSurface::getModel(){
    return model;
}

void LWSurface::setModel( Model *model ){
    this->model = model;
    /*dmsg( 
        M_LWS, 
        "Surface %s -> setModel( %s )", 
        model->getName().c_str(),
        name.c_str() 
    );*/
}


void LWSurface::processSubChunk(){
    if( f== (LWFile*)(0xfdfdfdfd) ){
        emsg( M_LWO, "ERROR" );
        return;
    }
    subchunk_id     = f->read_ID4();
    subchunk_length = f->read_U2 ();

    //did( subchunk_id );
    //cout << " subchunk of length " << subchunk_length << endl;

    f->pushDomain( subchunk_length );

    dmsg( M_LWO,
        "%s::SURF::%s (%d bytes)",
        did( f->getType() ),
        did( subchunk_id ),
        subchunk_length
    );

    switch( f->getType() ){
    case ID_LWOB:
        switch( subchunk_id ){
        case ID_COLR: readBaseColor_COL4                  (); break;
        case ID_FLAG: readStateFlags_U2                   (); break;
        case ID_LUMI: readLuminosity_IP2                  (); break;
        case ID_DIFF: readDiffuse_IP2                     (); break;
        case ID_SPEC: readSpecular_IP2_4                  (); break;
        case ID_REFL: readReflection_IP2_4                (); break;
        case ID_TRAN: readTransparency_IP2                (); break;
        case ID_VLUM: readLuminosity_FP4                  (); break;
        case ID_VDIF: readDiffuse_FP4                     (); break;
        case ID_VSPC: readSpecular_FP4                    (); break;
        case ID_VRFL: readReflection_FP4                  (); break;
        case ID_VTRN: readTransparency_FP4                (); break;
        case ID_GLOS: readSpecularGlossiness_I2_4         (); break;
        case ID_RFLT: readReflectionMode_U2               (); break;
        case ID_RIMG: readReflectionMapImage_FNAM0        (); break;
        case ID_RSAN: readReflectionMapImageSeamAngle_DEG4(); break;
        case ID_RIND: readRefractiveIndex_F4              (); break;
        case ID_EDGE: readEdgeTransparencyTreshold_F4     (); break;
        case ID_SMAN: readMaxSmoothingAngle_DEG4          (); break;
        case ID_ALPH: readAlphaMode_U2_U2                 (); break;
        case ID_SHDR: readShaderPlugin_S0                 (); break;
        case ID_SDAT: readShaderData_f                    (); break;
        case ID_IMSQ: readSequenceOptions_U2_U2_U2        (); break;
        case ID_FLYR: readFlyerClipOptions_U4_U4          (); break;
        case ID_IMCC: readColorCycleOptions_U2_U2_U2      (); break;
        case ID_CTEX: readColorTexture_S0                 (); break;
        case ID_DTEX: readDiffuseTexture_S0               (); break;
        case ID_STEX: readSpecularTexture_S0              (); break;
        case ID_RTEX: readReflectionTexture_S0            (); break;
        case ID_TTEX: readTransparencyTexture_S0          (); break;
        case ID_LTEX: readLuminosityTexture_S0            (); break;
        case ID_BTEX: readBumpTexture_S0                  (); break;

        //  Texture parameters are actually handled by current texture

        default:
            if( current_texture != NULL ){
                switch( subchunk_id ){
                case ID_TFLG: current_texture->readTextureFlags_U2          (); break;
                case ID_TSIZ: current_texture->readTextureSize_VEC12        (); break;
                case ID_TCTR: current_texture->readTextureCenter_VEC12      (); break;
                case ID_TFAL: current_texture->readTextureFallOff_VEC12     (); break;
                case ID_TVEL: current_texture->readTextureVelocity_VEC12    (); break;
                case ID_TREF: current_texture->readTextureReferenceObject_S0(); break;
                case ID_TCLR: current_texture->readTextureColor_COL4        (); break;
                case ID_TVAL: current_texture->readTextureValue_IP2         (); break;
                case ID_TAMP: current_texture->readBumpTextureAmplitude_FP4 (); break;
                case ID_TFP : current_texture->readTextureAlgorithm_F4      (); break;  // ns not yet handled
                case ID_TIP : current_texture->readTextureAlgorithm_I2      (); break;
                case ID_TSP : current_texture->readTextureAlgorithm_F4      (); break;  // obsolete
                case ID_TFRQ: current_texture->readTextureAlgorithm_I2      (); break;  // obsolete
                case ID_TIMG: current_texture->readImageMap_FNAM0           (); break;
                case ID_TALP: current_texture->readImageAlpha_FNAM0         (); break;
                case ID_TWRP: current_texture->readImageWarpOptions_U2_U2   (); break;
                case ID_TAAS: current_texture->readAntialiasingStrength_FP4 (); break;
                case ID_TOPC: current_texture->readTextureOpacity_FP4       (); break;
                default:
//                  cout << "handler not implemented\n";
                    break;
                        }
            }else{
                emsg( M_LWO, "There is no texture where to bind found texture subchunk\n" );
            }
            break;
        }
        break;

    case ID_LWO2:
        switch( subchunk_id ){
        case ID_COLR: readBaseColor_COL12_VX                 (); break;
        case ID_LUMI: readLuminosity_FP4_VX                  (); break;
        case ID_DIFF: readDiffuse_FP4_VX                     (); break;
        case ID_SPEC: readSpecular_FP4_VX                    (); break;
        case ID_REFL: readReflection_FP4_VX                  (); break;
        case ID_TRAN: readTransparency_FP4_VX                (); break;
        case ID_TRNL: readTranslucency_FP4_VX                (); break;
        case ID_GLOS: readSpecularGlossiness_FP4_VX          (); break;
        case ID_SHRP: readDiffuseSharpness_FP4_VX            (); break;
        case ID_BUMP: readBumpIntensity_FP4_VX               (); break;
        case ID_SIDE: readPolygonSidedness_U2                (); break;
        case ID_SMAN: readMaxSmoothingAngle_ANG4             (); break;
        case ID_RFOP: readReflectionOptions_U2               (); break;
        case ID_RIMG: readReflectionMapImage_VX              (); break;
        case ID_RSAN: readReflectionMapImageSeamAngle_ANG4_VX(); break;
        case ID_RIND: readRefractiveIndex_F4_VX              (); break;
        case ID_CLRH: readColorHighlights_FP4_VX             (); break;
        case ID_TROP: readTransparencyOptions_U2             (); break;
        case ID_TIMG: readRefractionMapImage_VX              (); break;
        case ID_CLRF: readColorFilter_FP4_VX                 (); break;
        case ID_ADTR: readAdditiveTransparency_FP4_VX        (); break;
        case ID_GLOW: readGlowEffect_U2_F4_VX_F4_VX          (); break;
        case ID_LINE: readRenderOutlines_U2_F4_VX_COL12_VX   (); break;
        case ID_ALPH: readAlphaMode_U2_FP4                   (); break;
        case ID_BLOK: readBlok                               (); break;
        case ID_CMNT: readComment_S0                         (); break;

        //  Texture parameters are actually handled by current texture

        default:
            if( current_texture != NULL ){
                switch( subchunk_id ){
                case ID_TFLG: current_texture->readTextureFlags_U2          (); break;
                case ID_TSIZ: current_texture->readTextureSize_VEC12        (); break;
                case ID_TCTR: current_texture->readTextureCenter_VEC12      (); break;
                case ID_TFAL: current_texture->readTextureFallOff_VEC12     (); break;
                case ID_TVEL: current_texture->readTextureVelocity_VEC12    (); break;
                case ID_TREF: current_texture->readTextureReferenceObject_S0(); break;
                case ID_TCLR: current_texture->readTextureColor_COL4        (); break;
                case ID_TVAL: current_texture->readTextureValue_IP2         (); break;
                case ID_TAMP: current_texture->readBumpTextureAmplitude_FP4 (); break;
                case ID_TFP : current_texture->readTextureAlgorithm_F4      (); break;  // ns not yet handled
                case ID_TIP : current_texture->readTextureAlgorithm_I2      (); break;
                case ID_TSP : current_texture->readTextureAlgorithm_F4      (); break;  // obsolete
                case ID_TFRQ: current_texture->readTextureAlgorithm_I2      (); break;  // obsolete
                case ID_TIMG: current_texture->readImageMap_FNAM0           (); break;
                case ID_TALP: current_texture->readImageAlpha_FNAM0         (); break;
                case ID_TWRP: current_texture->readImageWarpOptions_U2_U2   (); break;
                case ID_TAAS: current_texture->readAntialiasingStrength_FP4 (); break;
                case ID_TOPC: current_texture->readTextureOpacity_FP4       (); break;
                default:
                    dmsg( M_LWO, "Handler not implemented" );
                    break;
                }

            }else{
                dmsg( M_LWO, "There is no texture where to bind found texture subchunk" );
            }
            break;
        }
        break;

    default:
        dmsg( M_LWO, "handler not implemented" );
        break;
    }

    f->popDomain( true );
}


void LWSurface::endSurface(){
    endTexture();
}

void LWSurface::endTexture(){
    if( current_texture != NULL ){
        current_texture->applyTexture();
    }
    current_texture = NULL;
}


void LWSurface::setTexture( Texture *t, bool enable ){
    Material::setTexture( t, enable );
    if( t->isGood() ){
        useTextureColormap();
    }
}



void LWSurface::useTextureColormap(){
    baseColor = Color::WHITE;
    emission  = baseColor * luminosity_p;
    ambient   = baseColor * diffuse_p;
    diffuse   = baseColor * diffuse_p;
    specular  = Color::WHITE * specular_p;
}


void LWSurface::readBaseColor_COL4(){
    U1 red   = f->read_U1();
    U1 green = f->read_U1();
    U1 blue  = f->read_U1();
    (void)f->read_U1();

    baseColor = Color( red/255., green/255., blue/255. );
    emission  = baseColor * luminosity_p;
    ambient   = baseColor * diffuse_p;
    diffuse   = baseColor * diffuse_p;
    specular  = Color::WHITE * specular_p;
}


void LWSurface::readStateFlags_U2(){
    int count = 0;
    U2  flags = f->read_U2();
}


void LWSurface::readLuminosity_IP2(){
    luminosity_p = f->read_U2() / 255.0;
    emission  = baseColor * luminosity_p;
    ambient   = baseColor * diffuse_p;
    diffuse   = baseColor * diffuse_p;
    specular  = Color::WHITE * specular_p;
    dmsg( M_LWS, "LWSurface::readLuminosity_IP2()" );
    dmsg( M_LWS, "Object material luminosity %f", luminosity_p );
}


void LWSurface::readLuminosity_FP4(){
    luminosity_p = f->read_FP4();
    emission  = baseColor * luminosity_p;
    ambient   = baseColor * diffuse_p;
    diffuse   = baseColor * diffuse_p;
    specular  = Color::WHITE * specular_p;
    dmsg( M_LWS, "LWSurface::readLuminosity_FP4()" );
    dmsg( M_LWS, "Object material luminosity %f", luminosity_p );
}


void LWSurface::readDiffuse_IP2(){
    diffuse_p = f->read_U2() / 255.0;
    emission  = baseColor * luminosity_p;
    ambient   = baseColor * diffuse_p;
    diffuse   = baseColor * diffuse_p;
    specular  = Color::WHITE * specular_p;
}


void LWSurface::readDiffuse_FP4(){
    diffuse_p = f->read_FP4();
    emission  = baseColor * luminosity_p;
    ambient   = baseColor * diffuse_p;
    diffuse   = baseColor * diffuse_p;
    specular  = Color::WHITE * specular_p;
}


void LWSurface::readSpecular_IP2_4(){
    specular_p = f->read_U2() / 255.0;
    emission  = baseColor * luminosity_p;
    ambient   = baseColor * diffuse_p;
    diffuse   = baseColor * diffuse_p;
    specular  = Color::WHITE * specular_p;
}


void LWSurface::readSpecular_FP4(){
    specular_p = f->read_FP4();
    emission  = baseColor * luminosity_p;
    ambient   = baseColor * diffuse_p;
    diffuse   = baseColor * diffuse_p;
    specular  = Color::WHITE * specular_p;
}


void LWSurface::readSpecularGlossiness_I2_4(){
    U4 dl = f->domainLeft();
    if( dl != 2 ){
        emsg( M_LWO, "Domain left %ld bytes, expecting 2", dl );
    }

    I2 int_shi = f->read_I2();
    shininess = pow( 2, (10.0f * int_shi) + 2 );
//      cout << "Shininess " << shininess << endl;
    if( shininess < 0 ){
        dmsg( M_LWO,
            "Negative specular glossiness % 4.1f is invalid, replacing with zero.",
            shininess
        );
        shininess = 0;
    }
    if( shininess > 128 ){
        shininess = 128;
    }
    //lwo_debug_msg( "Glossiness %4.1f", shininess );
}


void LWSurface::readReflection_IP2_4(){}
void LWSurface::readTransparency_IP2(){}
void LWSurface::readReflection_FP4(){}
void LWSurface::readTransparency_FP4(){}
void LWSurface::readReflectionMode_U2(){}
void LWSurface::readReflectionMapImage_FNAM0(){}
void LWSurface::readReflectionMapImageSeamAngle_DEG4(){}
void LWSurface::readRefractiveIndex_F4(){}
void LWSurface::readEdgeTransparencyTreshold_F4(){}


void LWSurface::readMaxSmoothingAngle_DEG4(){
    max_smoothing_angle = f->read_ANG4();
}


void LWSurface::readAlphaMode_U2_U2(){}
void LWSurface::readShaderPlugin_S0(){}
void LWSurface::readShaderData_f(){}
void LWSurface::readSequenceOptions_U2_U2_U2(){}
void LWSurface::readFlyerClipOptions_U4_U4(){}
void LWSurface::readColorCycleOptions_U2_U2_U2(){}


void LWSurface::readColorTexture_S0(){
    S0 color_texture = f->read_S0();
    endTexture();
    current_texture = new LWTexture( this, getMapType(color_texture.c_str()) );
}


void LWSurface::readDiffuseTexture_S0(){
    S0 diffuse_texture = f->read_S0();
    //current_texture = new LWTexture( this, getMapType(diffuse_texture) );
}


void LWSurface::readSpecularTexture_S0(){
    S0 specular_texture = f->read_S0();
    //current_texture = new LWTexture( this, getMapType(specular_texture) );
}


void LWSurface::readReflectionTexture_S0(){
    S0 reflection_texture = f->read_S0();
    //current_texture = new LWTexture( this, getMapType(reflection_texture) );
}


void LWSurface::readTransparencyTexture_S0(){
    S0 transparency_texture = f->read_S0();
    //current_texture = new LWTexture( this, getMapType(transparency_texture) );
}


void LWSurface::readLuminosityTexture_S0(){
    S0 luminosity_texture = f->read_S0();
    //current_texture = new LWTexture( this, getMapType(luminosity_texture) );
}


void LWSurface::readBumpTexture_S0(){
    S0 bump_texture = f->read_S0();
    //current_texture = new LWTexture( this, getMapType(bump_texture) );
}


//  LWO2


void LWSurface::readComment_S0(){
    std::string comment = f->read_S0();
    if( strstr(comment.c_str(),"polygon_offset") != NULL ){
        setPolygonOffset( 1 );
//      printf( "Polygon offset enabled\n" );
    }
}

void LWSurface::readBaseColor_COL12_VX(){
    baseColor   = f->read_COL12();
    VX envelope = f->read_VX();     //  FIX envelope

    emission  = baseColor * luminosity_p;
    ambient   = baseColor * diffuse_p;
    diffuse   = baseColor * diffuse_p;
    specular  = Color::WHITE * specular_p;
}


void LWSurface::readLuminosity_FP4_VX(){
    luminosity_p = f->read_FP4();
    VX envelope  = f->read_VX();     //  FIX envelope

    emission  = baseColor * luminosity_p;
    ambient   = baseColor * diffuse_p;
    diffuse   = baseColor * diffuse_p;
    specular  = Color::WHITE * specular_p;
}


void LWSurface::readDiffuse_FP4_VX(){
    diffuse_p   = f->read_FP4();
    VX envelope = f->read_VX();     //  FIX envelope

    emission  = baseColor * luminosity_p;
    ambient   = baseColor * diffuse_p;
    diffuse   = baseColor * diffuse_p;
    specular  = Color::WHITE * specular_p;
}


void LWSurface::readSpecular_FP4_VX(){
    specular_p  = f->read_FP4();
    VX envelope = f->read_VX();     //  FIX envelope

    emission  = baseColor * luminosity_p;
    ambient   = baseColor * diffuse_p;
    diffuse   = baseColor * diffuse_p;
    specular  = Color::WHITE * specular_p;
}


void LWSurface::readReflection_FP4_VX(){
    reflection_p = f->read_FP4();
    VX envelope  = f->read_VX();     //  FIX envelope

    //  FIX no reflections yet? reflection = baseColor * reflection_p;
}


void LWSurface::readTransparency_FP4_VX(){
    transparency_p = f->read_FP4();
    VX envelope    = f->read_VX();     //  FIX envelope

    //  FIX no transparency yet
}


void LWSurface::readTranslucency_FP4_VX(){
    translucency_p = f->read_FP4();
    VX envelope    = f->read_VX();     //  FIX envelope

    //  FIX no translucency yet
}


void LWSurface::readSpecularGlossiness_FP4_VX(){
    float shi = f->read_FP4();
    shininess = pow( 2, (10.0f * shi) + 2 );
    if( shininess < 0 ){
        dmsg( M_LWO, "Negative specular glossiness %f is invalid, replacing with zero", shi );
        shininess = 0;
    }
    if( shininess > 128 ){
        shininess = 128;
    }
    VX envelope = f->read_VX();  //  FIX envelope
    //lwo_debug_msg( "Glossiness %4.1f", shininess );
}


void LWSurface::readDiffuseSharpness_FP4_VX(){
    FP4  sharpness = f->read_FP4();
    VX   envelope  = f->read_VX();   //  FIX envelope
    //  FIX Is this possible to be done with OpenGL?
}


void LWSurface::readBumpIntensity_FP4_VX(){
    FP4  streangth = f->read_FP4();
    VX   envelope  = f->read_VX();   //  FIX envelope
    //  FIX Neither am I :)
}


void LWSurface::readPolygonSidedness_U2(){
    U2 side = f->read_U2();
    switch( side ){
    case 1:
    case 2:
    case 3:
    default:
        break;
    }
}


void LWSurface::readMaxSmoothingAngle_ANG4(){
    max_smoothing_angle = f->read_ANG4();
}


void LWSurface::readReflectionOptions_U2(){
    U2 reflection_options = f->read_U2();
    //  FIX support for this
}


void LWSurface::readReflectionMapImage_VX(){
    VX reflection_map_image = f->read_VX();
    //  FIX support for this
}


void LWSurface::readReflectionMapImageSeamAngle_ANG4_VX(){
    ANG4  seam_angle = f->read_ANG4();
    VX    envelope   = f->read_VX();    //  FIX envelope
}


void LWSurface::readRefractiveIndex_F4_VX(){
    F4  refractive_index = f->read_F4();
    VX  envelope         = f->read_VX();  //  FIX envelope
    //  FIX support for this.. ?
}


void LWSurface::readColorHighlights_FP4_VX(){
    FP4 color_highlights = f->read_FP4();
    VX  envelope         = f->read_VX();   //  FIX envelope
}


void LWSurface::readTransparencyOptions_U2(){
    //  FIX support for this
}


void LWSurface::readRefractionMapImage_VX(){
    //  FIX support for this
}


void LWSurface::readColorFilter_FP4_VX(){
    FP4 color_filter = f->read_FP4();
    VX  envelope     = f->read_VX();   //  FIX envelope
    //  FIX support for this
}


void LWSurface::readAdditiveTransparency_FP4_VX(){
    FP4 additive = f->read_FP4();
    VX  envelope = f->read_VX();   //  FIX envelope
    //  FIX support for this
}


void LWSurface::readGlowEffect_U2_F4_VX_F4_VX(){
    U2 type               = f->read_U2();
    F4 intensity          = f->read_F4();
    VX intensity_envelope = f->read_VX();     //  FIX envelope
    F4 size               = f->read_F4();
    VX size_envelope      = f->read_VX();     //  FIX envelope
    //  Unclear to me too
    //  FIX support for this
}


void LWSurface::readRenderOutlines_U2_F4_VX_COL12_VX(){
    U2    flags          = f->read_U2();
    if( f->domainLeft()<4 ) return;
    F4    size           = f->read_F4();
    if( f->domainLeft()<4 ) return;
    VX    size_envelope  = f->read_VX();     //  FIX envelope
    Color color          = f->read_COL12();
    VX    color_envelope = f->read_VX();     //  FIX envelope
}


void LWSurface::readAlphaMode_U2_FP4(){
    //  FIX support for this
}


void LWSurface::readBlok(){
    LWSurfaceBlok *blok = new LWSurfaceBlok( this );
    blok->processBlok();
}


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


#endif  //  TEDDY_INCLUDE_LW_SCENE