You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
585 lines
26 KiB
585 lines
26 KiB
/*==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/>. |
|
|
|
Additional permissions under GNU GPL version 3 section 7 |
|
|
|
If you modify this Program, or any covered work, by linking or |
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
(or a modified version of those libraries), |
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
licensors of this Program grant you additional |
|
permission to convey the resulting work. Corresponding Source for a |
|
non-source form of such a combination shall include the source code for |
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
work. |
|
|
|
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==*/ |
|
#ifndef _pfJournalBook_h |
|
#define _pfJournalBook_h |
|
|
|
////////////////////////////////////////////////////////////////////////////// |
|
// // |
|
// pfJournalBook Class // |
|
// A generic, high-level, abstract method of creating various Myst-like // |
|
// books within the game with very little effort, while ensuring that they // |
|
// all remain consistent in appearance and operability. // |
|
// // |
|
////////////////////////////////////////////////////////////////////////////// |
|
// // |
|
// Journal books are created via a journal book template. The template // |
|
// takes the form of an extremely simplified version of HTML. The esHTML // |
|
// has the following tags defined: // |
|
// <p> - Start of a new paragraph. </p> isn't used. // |
|
// <img> - Places an image in-line with the text. Options are: // |
|
// align=left/right/center // |
|
// src=<name of plMipmap> // |
|
// link=<eventID> - Defines the image as clickable. When the user // |
|
// clicks the image, it will generate an event // |
|
// with the given event ID and send it to the // |
|
// calling Python handler. // |
|
// blend=none/alpha - Controls the blending method of drawing // |
|
// the image // |
|
// pos=<x>,<y> - Positions the image absolutely on the page // |
|
// using the upper-left pixel given. Absolute- // |
|
// placed images have no effect on text flow. // |
|
// glow=<seconds[,min,[max]]> // |
|
// - Defines a glow special effect, which amounts // |
|
// to the image oscillating in opacity across // |
|
// the time interval specified. Optionally, you // |
|
// can also specify the min and max opacity, // |
|
// from 0 to 1. // |
|
// check=<onColor,offColor,default> // |
|
// - Makes the image act as a checkbox, flipping // |
|
// between on and off states (as defined by the // |
|
// blending colors) on clicks. Default is either // |
|
// 1 for on or 0 for off. Link notifys are sent // |
|
// by checkboxes, with the event type // |
|
// "kNotifyCheckUnchecked" negative if the // |
|
// state is switching to off. Cannot be used // |
|
// with "glow". // |
|
// resize=yes/no - Defines whether the image will be resized // |
|
// with the book or not, defaults to yes // |
|
// opacity=0 to 1 - Defines the opacity of the image, 0 is // |
|
// completely transparent, 1 is opaque // |
|
// <pb> - Page break // |
|
// <font> - Set the font for the following text. Options are: // |
|
// face=<face name> // |
|
// size=<point size> // |
|
// style=r/b/i/bi // |
|
// color=rrggbb - Hex color // |
|
// spacing=<pixels> - line spacing in pixels // |
|
// <cover> - Optionally sets the cover mipmap for the book. // |
|
// src=<mipmap name> - Selects the mipmap to be used, using the // |
|
// same search methods as <img>. Unlike <img> // |
|
// though, <cover> has no restriction on // |
|
// mipmap format. // |
|
// tint=rrggbb - Hex color for tinting the cover image // |
|
// tintfirst=yes/no - Tint the cover before applying decals, // |
|
// defaults to yes. A no option overrides the // |
|
// individual tint options on the <decal> tags // |
|
// <margin> - Optionally sets the margin size in pixels, default is 16 // |
|
// top=<size> // |
|
// left=<size> // |
|
// bottom=<size> // |
|
// right=<size> // |
|
// <book> - Optionally sets the size of the book in percent (0-1), // |
|
// can be overridden by the SetBookSize funtion. // |
|
// height=<size> // |
|
// width=<size> // |
|
// <decal> - Optionally specifies a decal to be drawn on the cover in // |
|
// the specified position. Options are: // |
|
// src=<mipmap name> - Selects the mipmap to be used, using the // |
|
// same search methods as <imp>. Unlike <img> // |
|
// though, <decal> has no restrictions on // |
|
// mipmap format. // |
|
// pos=<x>,<y> - Specifies the position of the decal on the // |
|
// cover using the upper-left pixel // |
|
// align=left/right/center // |
|
// - Aligns the decal horizontally, overriding // |
|
// any x coord in the pos option, if no y has // |
|
// been specified, then it places it at the // |
|
// top of the cover // |
|
// resize=yes/no - Defines whether the image will be resized // |
|
// with the book or not, defaults to yes // |
|
// tint=yes/no - Defines whether or not this decal is tinted // |
|
// with the cover. Overridden by the tintfirst // |
|
// option on the <cover> tag. Defaults to no // |
|
// <movie> - Places a movie (.bik file) inline with the text. Options: // |
|
// src=<movie name> - Selects the movie to be used. (nead search // |
|
// methods here eventually) // |
|
// align=left/right/center // |
|
// - Aligns the movie horizontally, overriding // |
|
// any x coord in the pos option // |
|
// link=<eventID> - Defines the movie as clickable. When the // |
|
// User clicks the movie, it will generate an // |
|
// event with the given event ID and send it // |
|
// to the calling python handler // |
|
// pos=<x>,<y> - Specifies the position of the movie on the // |
|
// page using the upper left pixel given, does // |
|
// not influence text flow // |
|
// resize=yes/no - Defines whether the movie will be resized // |
|
// with the book or not, defaults to yes // |
|
// oncover=yes/no - Defines whether the movie will be placed on // |
|
// the cover or not, defaults to no. NOTE: // |
|
// setting this to yes causes the link option // |
|
// to be ignored since cover movies can't link // |
|
// loop=yes/no - Defines whether the movie will loop or not // |
|
// defaults to yes // |
|
// <editable> - Marks this book as editable (if the GUI supports it) // |
|
// // |
|
// The pages don't render until displayed. As a result, jumping to a given // |
|
// page requires each page from the current position to the destination // |
|
// to be rendered. Normally, this won't be a problem, because by default // |
|
// books open to the first page, at which point each page renders one // |
|
// at a time as the user flips through. // |
|
// // |
|
// The system assumes that no more than one book will ever actually be // |
|
// shown at any time. As a result, the internal geometry for displaying // |
|
// each book can be shared, reducing overhead and potential for errors. // |
|
// // |
|
////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include "HeadSpin.h" |
|
#include <map> |
|
|
|
#include "hsTemplates.h" |
|
#include "hsColorRGBA.h" |
|
|
|
#include "pnKeyedObject/hsKeyedObject.h" |
|
#include "pnKeyedObject/plUoid.h" |
|
|
|
|
|
|
|
class pfEsHTMLChunk; |
|
class pfGUIDialogMod; |
|
class plLocation; |
|
class pfGUICheckBoxCtrl; |
|
class pfGUIButtonMod; |
|
class pfJournalDlgProc; |
|
class plDynamicTextMap; |
|
class pfGUIClickMapCtrl; |
|
class plLayerInterface; |
|
class plMipmap; |
|
class pfGUIProgressCtrl; |
|
class hsGMaterial; |
|
class plLayerBink; |
|
class pfGUIMultiLineEditCtrl; |
|
|
|
class pfJournalBook; |
|
class pfBookMultiLineEditProc; |
|
|
|
class pfBookData : public hsKeyedObject |
|
{ |
|
public: |
|
enum WhichSide |
|
{ |
|
kLeftSide = 0x01, |
|
kRightSide = 0x02, |
|
kBothSides = 0x03, |
|
kNoSides = 0 |
|
}; |
|
|
|
enum DynDisplayIndex |
|
{ |
|
kLeftPage = 0, |
|
kRightPage, |
|
kTurnFrontPage, |
|
kTurnBackPage |
|
}; |
|
|
|
pfBookData(const plString &guiName = plString::Null); |
|
virtual ~pfBookData(); |
|
|
|
void LoadGUI(); // need this seperate because the plKey isn't setup until the constructor is done |
|
|
|
CLASSNAME_REGISTER(pfBookData); |
|
GETINTERFACE_ANY(pfBookData, hsKeyedObject); |
|
|
|
virtual bool MsgReceive(plMessage *pMsg); |
|
|
|
pfGUIDialogMod *Dialog() const {return fDialog;} |
|
pfGUICheckBoxCtrl *CoverButton() const {return fCoverButton;} |
|
pfGUICheckBoxCtrl *TurnPageButton() const {return fTurnPageButton;} |
|
pfGUIClickMapCtrl *LeftPageMap() const {return fLeftPageMap;} |
|
pfGUIClickMapCtrl *RightPageMap() const {return fRightPageMap;} |
|
plLayerInterface *CoverLayer() const {return fCoverLayer;} |
|
hsGMaterial *CoverMaterial() const {return fCoverMaterial;} |
|
hsGMaterial *PageMaterial(int index) const {if ((index<0)||(index>3)) return nil; else return fPageMaterials[index];} |
|
pfGUIButtonMod *LeftCorner() const {return fLeftCorner;} |
|
pfGUIButtonMod *RightCorner() const {return fRightCorner;} |
|
pfGUIProgressCtrl *WidthCtrl() const {return fWidthCtrl;} |
|
pfGUIProgressCtrl *HeightCtrl() const {return fHeightCtrl;} |
|
plMipmap *DefaultCover() const {return fDefaultCover;} |
|
pfJournalBook *CurBook() const {return fCurrBook;} |
|
|
|
bool StartedOpen() {return fStartedOpen;} |
|
bool CurrentlyOpen() {return fCurrentlyOpen;} |
|
bool CurrentlyTurning() {return fCurrentlyTurning;} |
|
bool IsEditable() {return fEditable;} |
|
WhichSide CurSFXPages() {return fCurrSFXPages;} |
|
|
|
void StartedOpen(bool startedOpen) {fStartedOpen = startedOpen;} |
|
void CurrentlyOpen(bool currentlyOpen) {fCurrentlyOpen = currentlyOpen;} |
|
void CurrentlyTurning(bool currentlyTurning) {fCurrentlyTurning = currentlyTurning;} |
|
void CurBook(pfJournalBook *curBook) {fCurrBook = curBook;} |
|
|
|
// Quick helper |
|
plDynamicTextMap *GetDTMap(uint32_t which); |
|
pfGUIMultiLineEditCtrl *GetEditCtrl(uint32_t which); |
|
|
|
// Seeks the width and height animations to set the desired book size. Sizes are in % across the animation |
|
void SetCurrSize(float w, float h); |
|
|
|
// Enables or disables the left and right page corners, to indicate current turnage state |
|
void UpdatePageCorners(WhichSide which); |
|
|
|
// Plays our book close animation |
|
void PlayBookCloseAnim(bool closeIt = true, bool immediate = false); |
|
|
|
// Finishes the start of the triggered page flip (once we're sure the animation is at the new frame) |
|
void StartTriggeredFlip(bool flipBackwards); |
|
|
|
// kill the flipping of a page... we are probably closing the book |
|
void KillPageFlip(); |
|
|
|
// Registers (or unregisters) for time messages so we can process special FX if we need to |
|
void RegisterForSFX(WhichSide whichSides); |
|
|
|
void HitEndOfControlList(int32_t cursorPos); |
|
void HitBeginningOfControlList(int32_t cursorPos); |
|
|
|
void EnableEditGUI(bool enable=true); |
|
void DisableEditGUI() {EnableEditGUI(false);} |
|
|
|
protected: |
|
friend class pfJournalDlgProc; |
|
|
|
enum Refs |
|
{ |
|
kRefDialog = 0, |
|
kRefDefaultCover |
|
}; |
|
|
|
plString fGUIName; |
|
|
|
// The pointer to our dialog |
|
pfGUIDialogMod *fDialog; |
|
|
|
// And other interesting pointers |
|
pfGUICheckBoxCtrl *fCoverButton; |
|
pfGUICheckBoxCtrl *fTurnPageButton; |
|
pfGUIClickMapCtrl *fLeftPageMap; |
|
pfGUIClickMapCtrl *fRightPageMap; |
|
plLayerInterface *fCoverLayer; |
|
hsGMaterial *fCoverMaterial; |
|
hsGMaterial *fPageMaterials[4]; |
|
pfGUIButtonMod *fLeftCorner; |
|
pfGUIButtonMod *fRightCorner; |
|
pfGUIProgressCtrl *fWidthCtrl; |
|
pfGUIProgressCtrl *fHeightCtrl; |
|
|
|
pfGUIMultiLineEditCtrl *fLeftEditCtrl; |
|
pfGUIMultiLineEditCtrl *fRightEditCtrl; |
|
pfGUIMultiLineEditCtrl *fTurnFrontEditCtrl; |
|
pfGUIMultiLineEditCtrl *fTurnBackEditCtrl; |
|
|
|
// Pointer to our default (base) cover mipmap |
|
plMipmap *fDefaultCover; |
|
|
|
// The current book using our data |
|
pfJournalBook *fCurrBook; |
|
|
|
// Which side(s) we're currently doing SFX for |
|
WhichSide fCurrSFXPages; |
|
|
|
// Base time to calc SFX anim positions from |
|
float fBaseSFXTime; |
|
bool fResetSFXFlag; |
|
bool fSFXUpdateFlip; // So we only update alternating pages every frame, to save processor time |
|
|
|
// What it says |
|
bool fCurrentlyTurning, fCurrentlyOpen, fStartedOpen; |
|
|
|
bool fEditable; |
|
int32_t fAdjustCursorTo; |
|
|
|
// Inits our dialog template |
|
void IInitTemplate(pfGUIDialogMod *templateDlg); |
|
|
|
// Process SFX for this frame |
|
void IHandleSFX(float currTime, WhichSide whichSide = kNoSides); |
|
|
|
// Yet another step in the page flip, to make SURE we're already showing the turning page before we fill in the page behind it |
|
void IFillUncoveringPage(bool rightSide); |
|
|
|
// Triggers the start of the page-flipping animation, as well as sets up the callback for when it's finished |
|
void ITriggerPageFlip(bool flipBackwards, bool immediate); |
|
|
|
// Finishes the triggered page flip, on callback |
|
void IFinishTriggeredFlip(bool wasBackwards); |
|
}; |
|
|
|
class pfJournalBook : public hsKeyedObject |
|
{ |
|
public: |
|
|
|
// Enums of event types for the Book plNotifyMsg type |
|
enum NotifyTypes |
|
{ |
|
kNotifyImageLink = 0, |
|
kNotifyShow, |
|
kNotifyHide, |
|
kNotifyNextPage, |
|
kNotifyPreviousPage, |
|
kNotifyCheckUnchecked, |
|
kNotifyClose, |
|
}; |
|
|
|
// The constructor takes in the esHTML source for the journal, along with |
|
// the name of the mipmap to use as the cover of the book. The callback |
|
// key is the keyed object to send event messages to (see <img> tag). |
|
pfJournalBook( const char *esHTMLSource, plKey coverImageKey = nil, plKey callbackKey = nil, const plLocation &hintLoc = plLocation::kGlobalFixedLoc, const plString &guiName = plString::Null ); |
|
pfJournalBook( const wchar_t *esHTMLSource, plKey coverImageKey = nil, plKey callbackKey = nil, const plLocation &hintLoc = plLocation::kGlobalFixedLoc, const plString &guiName = plString::Null ); |
|
|
|
virtual ~pfJournalBook(); |
|
|
|
CLASSNAME_REGISTER( pfJournalBook ); |
|
GETINTERFACE_ANY( pfJournalBook, hsKeyedObject ); |
|
|
|
// Our required virtual |
|
virtual bool MsgReceive( plMessage *pMsg ); |
|
|
|
// Init the singleton, for client startup |
|
static void SingletonInit( void ); |
|
|
|
// Shutdown the singleton |
|
static void SingletonShutdown( void ); |
|
|
|
// loads a gui |
|
static void LoadGUI( const plString &guiName ); |
|
|
|
// unloads a gui if we don't need it any more and want to free up memory |
|
static void UnloadGUI( const plString &guiName ); |
|
|
|
// unloads all GUIs except for the default |
|
static void UnloadAllGUIs(); |
|
|
|
void SetGUI( const plString &guiName ); |
|
|
|
// Shows the book, optionally starting open or closed |
|
void Show( bool startOpened = false ); |
|
|
|
|
|
/// NOTE: The following functions expose functionality that is normally |
|
/// handled by the book logic itself. So you should only need to use these |
|
/// in unusual circumstances. |
|
|
|
|
|
// Book handles hiding itself once someone clicks away. |
|
void Hide( void ); |
|
|
|
// Opens the book, optionally to the given page |
|
void Open( uint32_t startingPage = 0 ); |
|
|
|
// Closes the book. |
|
void Close( void ); |
|
|
|
// Advances forward one page |
|
void NextPage( void ); |
|
|
|
// Same, only back |
|
void PreviousPage( void ); |
|
|
|
// For completeness... |
|
void GoToPage( uint32_t pageNumber ); |
|
|
|
// See below. Just forces a full calc of the cached info |
|
void ForceCacheCalculations( void ); |
|
|
|
// Closes the book, then calls Hide() once it's done closing |
|
void CloseAndHide( void ); |
|
|
|
// Sets the book size scaling. 1,1 would be full size, 0,0 is the smallest size possible |
|
void SetBookSize( float width, float height ); |
|
|
|
// What page are we on? |
|
uint32_t GetCurrentPage( void ) const { return fCurrentPage; } |
|
|
|
// Set the margin (defaults to 16 pixels) |
|
void SetPageMargin( uint32_t margin ) { fPageTMargin = fPageLMargin = fPageBMargin = fPageRMargin = margin; } |
|
|
|
// Turns on or off page turning |
|
void AllowPageTurning( bool allow ) { fAllowTurning = allow; } |
|
|
|
// grabs a certain movie based on it's index in the source file |
|
plKey GetMovie( uint8_t index ); |
|
|
|
// turns on and off editing of the book |
|
void SetEditable( bool editable=true ); |
|
|
|
// returns the text contained by the edit controls |
|
std::string GetEditableText(); |
|
|
|
void SetEditableText(std::string text); |
|
|
|
protected: |
|
|
|
struct loadedMovie |
|
{ |
|
pfEsHTMLChunk *movieChunk; |
|
plLayerBink *movieLayer; |
|
}; |
|
|
|
friend class pfJournalDlgProc; |
|
friend class pfBookData; |
|
|
|
// Our compiled esHTML source |
|
std::wstring fUncompiledSource; |
|
plLocation fDefLoc; |
|
hsTArray<pfEsHTMLChunk *> fHTMLSource; |
|
hsTArray<pfEsHTMLChunk *> fCoverDecals; // stored in a separate location so we can draw them all immediately |
|
|
|
hsTArray<loadedMovie *> fLoadedMovies; |
|
|
|
// The key of the mipmap to use as the cover image |
|
plKey fCoverMipKey; |
|
bool fTintCover; |
|
hsColorRGBA fCoverTint; |
|
bool fTintFirst; // tint before applying decals? |
|
|
|
// Receiver key to send notifys to, if any |
|
plKey fCallbackKey; |
|
bool fCoverFromHTML; |
|
// Cached array of page starts in the esHTML source. Generated as we flip through |
|
// the book, so that going backwards can be done efficiently. |
|
hsTArray<uint32_t> fPageStarts; |
|
|
|
// is the book done showing and ready for more page calculations |
|
bool fAreWeShowing; |
|
|
|
// Our current page |
|
uint32_t fCurrentPage; |
|
|
|
// are we editing this book? (adjusts how we draw and flip pages) |
|
bool fAreEditing; |
|
bool fWantEditing; // the code specifies that we want to edit, but the gui doesn't support it, we will check again if the gui changes |
|
|
|
bool fAllowTurning; // do we allow the user to turn pages? |
|
|
|
// The ending page. -1 until calculated by flipping to it |
|
uint32_t fLastPage; |
|
|
|
// Per book size |
|
float fWidthScale, fHeightScale; |
|
|
|
// Per book margin around the edge (defaults to 16 pixels) |
|
uint32_t fPageTMargin, fPageLMargin, fPageBMargin, fPageRMargin; |
|
|
|
// Some animation keys we use |
|
plKey fPageTurnAnimKey; |
|
|
|
// Current list of linkable image chunks we have visible on the screen, for quick hit testing |
|
hsTArray<pfEsHTMLChunk *> fVisibleLinks; |
|
|
|
static std::map<plString,pfBookData*> fBookGUIs; |
|
plString fCurBookGUI; |
|
|
|
enum Refs |
|
{ |
|
kRefImage = 0 |
|
}; |
|
|
|
// Compiles the given string of esHTML source into our compiled chunk list |
|
bool ICompileSource( const wchar_t *source, const plLocation &hintLoc ); |
|
|
|
// Frees our source array |
|
void IFreeSource( void ); |
|
|
|
// Compile helpers |
|
uint8_t IGetTagType( const wchar_t *string ); |
|
bool IGetNextOption( const wchar_t *&string, wchar_t *name, wchar_t *option ); |
|
|
|
plKey IGetMipmapKey( const wchar_t *name, const plLocation &loc ); |
|
|
|
// Renders one (1) page into the given DTMap |
|
void IRenderPage( uint32_t page, uint32_t whichDTMap, bool suppressRendering = false ); |
|
|
|
// moves the movie layers from one material onto another |
|
void IMoveMovies( hsGMaterial *source, hsGMaterial *dest); |
|
|
|
// Starting at the given chunk, works backwards to determine the full set of current |
|
// font properties at that point, or assigns defaults if none were specified |
|
void IFindFontProps( uint32_t chunkIdx, const wchar_t *&face, uint8_t &size, uint8_t &flags, hsColorRGBA &color, int16_t &spacing ); |
|
|
|
// Find the last paragraph chunk and thus the last par alignment settings |
|
uint8_t IFindLastAlignment( void ) const; |
|
|
|
// Handle clicks on either side of the book |
|
void IHandleLeftSideClick( void ); |
|
void IHandleRightSideClick( void ); |
|
|
|
// Just sends out a notify to our currently set receiver key |
|
void ISendNotify( uint32_t type, uint32_t linkID = 0 ); |
|
|
|
// Close with a notify |
|
void ITriggerCloseWithNotify( bool closeNotOpen, bool immediate ); |
|
|
|
// Finish showing the book, due to the animation being done seeking |
|
void IFinishShow( bool startOpened ); |
|
|
|
// Find the current moused link, if any |
|
int32_t IFindCurrVisibleLink( bool rightNotLeft, bool hoverNotUp ); |
|
|
|
// Ensures that all the page starts are calced up to the given page (but not including it) |
|
void IRecalcPageStarts( uint32_t upToPage ); |
|
|
|
// Load (or unload) all the images for the book |
|
void ILoadAllImages( bool unload ); |
|
|
|
// Purge the DynaTextMaps |
|
void IPurgeDynaTextMaps( ); |
|
|
|
// Process a click on the given "check box" image |
|
void IHandleCheckClick( uint32_t idx, pfBookData::WhichSide which ); |
|
|
|
// Draw me an image! |
|
void IDrawMipmap( pfEsHTMLChunk *chunk, uint16_t x, uint16_t y, plMipmap *mip, plDynamicTextMap *dtMap, uint32_t whichDTMap, bool dontRender ); |
|
|
|
// Movie functions |
|
loadedMovie *IMovieAlreadyLoaded(pfEsHTMLChunk *chunk); |
|
loadedMovie *IGetMovieByIndex(uint8_t index); |
|
plLayerBink *IMakeMovieLayer(pfEsHTMLChunk *chunk, uint16_t x, uint16_t y, plMipmap *baseMipmap, uint32_t whichDTMap, bool dontRender); |
|
|
|
// Cover functions |
|
plLayerInterface *IMakeBaseLayer(plMipmap *image); |
|
plLayerInterface *IMakeDecalLayer(pfEsHTMLChunk *decalChunk, plMipmap *decal, plMipmap *baseMipmap); |
|
void ISetDecalLayers(hsGMaterial *material,hsTArray<plLayerInterface*> layers); |
|
}; |
|
|
|
|
|
#endif //_pfJournalBook_h
|
|
|