aboutsummaryrefslogtreecommitdiff
path: root/engines/bladerunner/slice_renderer.h
blob: aeca8c6c2d0bb4c6ffa8bd8e2a97ecfa6f3a144c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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 2
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#ifndef BLADERUNNER_SLICE_RENDERER_H
#define BLADERUNNER_SLICE_RENDERER_H

#include "bladerunner/color.h"
#include "bladerunner/vector.h"
#include "bladerunner/view.h"
#include "bladerunner/matrix.h"

#include "common/rect.h"

#include "graphics/surface.h"

namespace Common {
class MemoryReadStream;
}

namespace BladeRunner {

class ScreenEffects;
class BladeRunnerEngine;
class Lights;
class SetEffects;

class SliceRenderer {
	BladeRunnerEngine *_vm;

	int       _animation;
	int       _frame;
	Vector3   _position;
	float     _facing;
	float     _scale;

	ScreenEffects       *_screenEffects;
	View        _view;
	Lights     *_lights;
	SetEffects *_setEffects;

	void       *_sliceFramePtr;

	// Animation frame data
	Vector2 _frameScale;
	float   _frameBottomZ;
	Vector2 _framePos;
	float   _frameSliceHeight;
	uint32  _framePaletteIndex;
	uint32  _frameSliceCount;

	Matrix3x2    _modelMatrix;
	Vector3      _startScreenVector;
	Vector3      _endScreenVector;
	float        _startSlice;
	float        _endSlice;
	Common::Rect _screenRectangle;

	int _m11lookup[256];
	int _m12lookup[256];
	int _m13;
	int _m21lookup[256];
	int _m22lookup[256];
	int _m23;

	bool _animationsShadowEnabled[997];

	Color _setEffectColor;
	Color _lightsColor;

	Graphics::PixelFormat _pixelFormat;

	Matrix3x2 calculateFacingRotationMatrix();
	void drawSlice(int slice, bool advanced, uint16 *frameLinePtr, uint16 *zbufLinePtr, int y);

public:
	SliceRenderer(BladeRunnerEngine *vm);
	~SliceRenderer();

	void setScreenEffects(ScreenEffects *aesc);
	void setView(const View &view);
	void setLights(Lights *lights);
	void setSetEffects(SetEffects *setEffects);

	void setupFrameInWorld(int animationId, int animationFrame, Vector3 position, float facing, float scale = 1.0f);
	void getScreenRectangle(Common::Rect *screenRectangle, int animationId, int animationFrame, Vector3 position, float facing, float scale);
	void drawInWorld(int animationId, int animationFrame, Vector3 position, float facing, float scale, Graphics::Surface &surface, uint16 *zbuffer);

	void drawOnScreen(int animationId, int animationFrame, int screenX, int screenY, float facing, float scale, Graphics::Surface &surface, uint16 *zbuffer);

	void preload(int animationId);

	void disableShadows(int *animationsIdsList, int listSize);

private:

	void calculateBoundingRect();
	void loadFrame(int animation, int frame);
};

class SliceRendererLights {
	Lights *_lights;
	Color   _cacheColor[20];
	float   _cacheCounter[20];
	float   _cacheStart[20];
	int     _cacheRecalculation;

public:
	Color   _finalColor;

public:
	SliceRendererLights(Lights *lights);

	void calculateColorBase(Vector3 position1, Vector3 position2, float height);
	void calculateColorSlice(Vector3 position);
};

} // End of namespace BladeRunner

#endif